Added ToJson to JSON schema compiler.

Also re-factored the recently landed Debugger api (I believe it's the only API to have compiled events, so far)

BUG=138767


Review URL: https://chromiumcodereview.appspot.com/10796114

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@148878 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/extensions/api/debugger/debugger_api.cc

@@ -254,10 +254,7 @@ void ExtensionDevToolsClientHost::SendDetachedEvent() {
     Debuggee debuggee;
     debuggee.tab_id = tab_id_;
 
-    scoped_ptr<base::ListValue> args(OnDetach::Create(debuggee));
-    std::string json_args;
-    base::JSONWriter::Write(args.get(), &json_args);
-
+    std::string json_args = OnDetach::ToJson(debuggee);
     profile->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, keys::kOnDetach, json_args, profile, GURL());
   }
@@ -310,9 +307,7 @@ void ExtensionDevToolsClientHost::DispatchOnInspectorFrontend(
     if (dictionary->GetDictionary("params", &params_value))
       params.additional_properties.Swap(params_value);
 
-    scoped_ptr<ListValue> args(OnEvent::Create(debuggee, method_name, params));
-    std::string json_args;
-    base::JSONWriter::Write(args.get(), &json_args);
+    std::string json_args = OnEvent::ToJson(debuggee, method_name, params);
 
     profile->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, keys::kOnEvent, json_args, profile, GURL());

tools/json_schema_compiler/cc_generator.py

@@ -88,7 +88,7 @@ class CCGenerator(object):
       )
     for event in self._namespace.events.values():
       (c.Concat(self._GenerateCreateCallbackArguments(
-          cpp_util.Classname(event.name), event))
+          cpp_util.Classname(event.name), event, generate_to_json=True))
         .Append()
       )
     (c.Concat(self._cpp_type_generator.GetNamespaceEnd())
@@ -689,7 +689,10 @@ class CCGenerator(object):
     )
     return c
 
-  def _GenerateCreateCallbackArguments(self, function_scope, callback):
+  def _GenerateCreateCallbackArguments(self,
+                                       function_scope,
+                                       callback,
+                                       generate_to_json=False):
     """Generate all functions to create Value parameters for a callback.
 
     E.g for function "Bar", generate Bar::Results::Create
@@ -698,6 +701,7 @@ class CCGenerator(object):
     function_scope: the function scope path, e.g. Foo::Bar for the function
     Foo::Bar::Baz().
     callback: the Function object we are creating callback arguments for.
+    generate_to_json: Generate a ToJson method.
     """
     c = Code()
     params = callback.params
@@ -724,9 +728,22 @@ class CCGenerator(object):
 
       c.Append('return create_results.Pass();')
       c.Eblock('}')
+      if generate_to_json:
+        c.Append()
+        (c.Sblock('std::string %(function_scope)s::'
+                  'ToJson(%(declaration_list)s) {')
+          .Append('scoped_ptr<base::ListValue> create_results = '
+                  '%(function_scope)s::Create(%(param_list)s);')
+          .Append('std::string json;')
+          .Append('base::JSONWriter::Write(create_results.get(), &json);')
+          .Append('return json;')
+        )
+        c.Eblock('}')
+
       c.Substitute({
           'function_scope': function_scope,
-          'declaration_list': ', '.join(declaration_list)
+          'declaration_list': ', '.join(declaration_list),
+          'param_list': ', '.join(param.unix_name for param in param_list)
       })
 
     return c

tools/json_schema_compiler/cpp_type_generator.py

@@ -222,6 +222,8 @@ class CppTypeGenerator(object):
                       self._cpp_namespaces[dependency])
          for dependency in self._NamespaceTypeDependencies().keys()]):
       c.Append('#include "%s"' % header)
+    if self._namespace.events:
+      c.Append('#include "base/json/json_writer.h"')
     return c
 
   def _ResolveTypeNamespace(self, ref_type):

tools/json_schema_compiler/cpp_type_generator_test.py

@@ -39,14 +39,18 @@ class CppTypeGeneratorTest(unittest.TestCase):
     self.model.AddNamespace(self.dependency_tester_json[0],
                             'path/to/dependency_tester.json')
     self.dependency_tester = self.model.namespaces.get('dependencyTester')
+    self.content_settings_json = CachedLoad('test/content_settings.json')
+    self.model.AddNamespace(self.content_settings_json[0],
+                            'path/to/content_settings.json')
+    self.content_settings = self.model.namespaces.get('contentSettings')
 
   def testGenerateIncludesAndForwardDeclarations(self):
     manager = CppTypeGenerator('', self.windows, self.windows.unix_name)
     manager.AddNamespace(self.tabs, self.tabs.unix_name)
-    self.assertEquals('#include "path/to/tabs.h"',
+    self.assertEquals('#include "path/to/tabs.h"\n'
+                      '#include "base/json/json_writer.h"',
                       manager.GenerateIncludes().Render())
-    self.assertEquals(
-        'namespace tabs {\n'
+    self.assertEquals('namespace tabs {\n'
                       'struct Tab;\n'
                       '}\n'
                       'namespace windows {\n'
@@ -54,11 +58,16 @@ class CppTypeGeneratorTest(unittest.TestCase):
                       '}  // windows',
                       manager.GenerateForwardDeclarations().Render())
     manager = CppTypeGenerator('', self.permissions, self.permissions.unix_name)
-    self.assertEquals('', manager.GenerateIncludes().Render())
+    self.assertEquals('#include "base/json/json_writer.h"',
+                      manager.GenerateIncludes().Render())
     self.assertEquals('namespace permissions {\n'
                       'struct Permissions;\n'
                       '}  // permissions',
                       manager.GenerateForwardDeclarations().Render())
+    manager = CppTypeGenerator('', self.content_settings,
+                               self.content_settings.unix_name)
+    self.assertEquals('', manager.GenerateIncludes().Render())
+
 
   def testGenerateIncludesAndForwardDeclarationsMultipleTypes(self):
     m = model.Model()
@@ -73,10 +82,10 @@ class CppTypeGeneratorTest(unittest.TestCase):
                                     'path/to/tabs.json')
     manager = CppTypeGenerator('', windows, self.windows.unix_name)
     manager.AddNamespace(tabs_namespace, self.tabs.unix_name)
-    self.assertEquals('#include "path/to/tabs.h"',
+    self.assertEquals('#include "path/to/tabs.h"\n'
+                      '#include "base/json/json_writer.h"',
                       manager.GenerateIncludes().Render())
-    self.assertEquals(
-        'namespace tabs {\n'
+    self.assertEquals('namespace tabs {\n'
                       'struct Permissions;\n'
                       'struct Tab;\n'
                       '}\n'
@@ -102,8 +111,7 @@ class CppTypeGeneratorTest(unittest.TestCase):
     self.assertEquals('#include "path/to/browser_action.h"\n'
                       '#include "path/to/font_settings.h"',
                       manager.GenerateIncludes().Render())
-    self.assertEquals(
-        'namespace browserAction {\n'
+    self.assertEquals('namespace browserAction {\n'
                       'typedef std::vector<int> ColorArray;\n'
                       '}\n'
                       'namespace fontSettings {\n'
@@ -118,56 +126,58 @@ class CppTypeGeneratorTest(unittest.TestCase):
     prop = self.tabs.functions['move'].params[0]
     self.assertEquals('TAB_IDS_ARRAY',
                       manager.GetEnumValue(prop, model.PropertyType.ARRAY.name))
-    self.assertEquals('TAB_IDS_INTEGER',
+    self.assertEquals(
+        'TAB_IDS_INTEGER',
         manager.GetEnumValue(prop, model.PropertyType.INTEGER.name))
     self.assertEquals('TabIdsType',
                       manager.GetChoicesEnumType(prop))
 
   def testGetTypeSimple(self):
     manager = CppTypeGenerator('', self.tabs, self.tabs.unix_name)
-    self.assertEquals('int',
-        manager.GetType(
-        self.tabs.types['tabs.Tab'].properties['id']))
-    self.assertEquals('std::string',
-        manager.GetType(
-        self.tabs.types['tabs.Tab'].properties['status']))
-    self.assertEquals('bool',
-        manager.GetType(
-        self.tabs.types['tabs.Tab'].properties['selected']))
+    self.assertEquals(
+        'int',
+        manager.GetType(self.tabs.types['tabs.Tab'].properties['id']))
+    self.assertEquals(
+        'std::string',
+        manager.GetType(self.tabs.types['tabs.Tab'].properties['status']))
+    self.assertEquals(
+        'bool',
+        manager.GetType(self.tabs.types['tabs.Tab'].properties['selected']))
 
   def testStringAsType(self):
     manager = CppTypeGenerator('', self.font_settings,
                                self.font_settings.unix_name)
-    self.assertEquals('std::string',
-        manager.GetType(
-        self.font_settings.types['fontSettings.ScriptCode']))
+    self.assertEquals(
+        'std::string',
+        manager.GetType(self.font_settings.types['fontSettings.ScriptCode']))
 
   def testArrayAsType(self):
     manager = CppTypeGenerator('', self.browser_action,
                                self.browser_action.unix_name)
-    self.assertEquals('std::vector<int>',
-        manager.GetType(
-        self.browser_action.types['browserAction.ColorArray']))
+    self.assertEquals(
+        'std::vector<int>',
+        manager.GetType(self.browser_action.types['browserAction.ColorArray']))
 
   def testGetTypeArray(self):
     manager = CppTypeGenerator('', self.windows, self.windows.unix_name)
-    self.assertEquals('std::vector<linked_ptr<Window> >',
-        manager.GetType(
-        self.windows.functions['getAll'].callback.params[0]))
+    self.assertEquals(
+        'std::vector<linked_ptr<Window> >',
+        manager.GetType(self.windows.functions['getAll'].callback.params[0]))
     manager = CppTypeGenerator('', self.permissions, self.permissions.unix_name)
     self.assertEquals('std::vector<std::string>', manager.GetType(
       self.permissions.types['permissions.Permissions'].properties['origins']))
 
   def testGetTypeLocalRef(self):
     manager = CppTypeGenerator('', self.tabs, self.tabs.unix_name)
-    self.assertEquals('Tab',
-        manager.GetType(
-        self.tabs.functions['get'].callback.params[0]))
+    self.assertEquals(
+        'Tab',
+        manager.GetType(self.tabs.functions['get'].callback.params[0]))
 
   def testGetTypeIncludedRef(self):
     manager = CppTypeGenerator('', self.windows, self.windows.unix_name)
     manager.AddNamespace(self.tabs, self.tabs.unix_name)
-    self.assertEquals('std::vector<linked_ptr<tabs::Tab> >',
+    self.assertEquals(
+        'std::vector<linked_ptr<tabs::Tab> >',
         manager.GetType(
             self.windows.types['windows.Window'].properties['tabs']))
 
@@ -197,8 +207,7 @@ class CppTypeGeneratorTest(unittest.TestCase):
   def testNamespaceDeclaration(self):
     manager = CppTypeGenerator('extensions', self.permissions,
                                self.permissions.unix_name)
-    self.assertEquals(
-        'namespace extensions {',
+    self.assertEquals('namespace extensions {',
                       manager.GetRootNamespaceStart().Render())
 
     manager = CppTypeGenerator('extensions::gen::api', self.permissions,
@@ -207,13 +216,11 @@ class CppTypeGeneratorTest(unittest.TestCase):
                       manager.GetNamespaceStart().Render())
     self.assertEquals('}  // permissions',
                       manager.GetNamespaceEnd().Render())
-    self.assertEquals(
-        'namespace extensions {\n'
+    self.assertEquals('namespace extensions {\n'
                       'namespace gen {\n'
                       'namespace api {',
                       manager.GetRootNamespaceStart().Render())
-    self.assertEquals(
-        '}  // api\n'
+    self.assertEquals('}  // api\n'
                       '}  // gen\n'
                       '}  // extensions',
                       manager.GetRootNamespaceEnd().Render())

tools/json_schema_compiler/cpp_util.py

@@ -65,7 +65,7 @@ def GetParameterDeclaration(param, type_):
   type.
   """
   if param.type_ in (PropertyType.REF, PropertyType.OBJECT, PropertyType.ARRAY,
-      PropertyType.STRING):
+      PropertyType.STRING, PropertyType.ANY):
     arg = '%(type)s& %(name)s'
   else:
     arg = '%(type)s %(name)s'

tools/json_schema_compiler/h_generator.py

@@ -230,7 +230,8 @@ class HGenerator(object):
     """
     c = Code()
     (c.Sblock('namespace %s {' % cpp_util.Classname(event.name))
-        .Concat(self._GenerateCreateCallbackArguments(event))
+        .Concat(self._GenerateCreateCallbackArguments(event,
+                                                      generate_to_json=True))
       .Eblock('};')
     )
     return c
@@ -324,7 +325,7 @@ class HGenerator(object):
               cpp_util.Classname(prop.name)))
     return c
 
-  def _GenerateCreateCallbackArguments(self, function):
+  def _GenerateCreateCallbackArguments(self, function, generate_to_json=False):
     """Generates functions for passing paramaters to a callback.
     """
     c = Code()
@@ -341,6 +342,8 @@ class HGenerator(object):
             param, self._cpp_type_generator.GetType(param)))
       c.Append('scoped_ptr<base::ListValue> Create(%s);' %
                ', '.join(declaration_list))
+      if generate_to_json:
+        c.Append('std::string ToJson(%s);' % ', '.join(declaration_list))
     return c
 
   def _GenerateFunctionResults(self, callback):

tools/json_schema_compiler/test/objects_unittest.cc

@@ -4,6 +4,7 @@
 
 #include "tools/json_schema_compiler/test/objects.h"
 
+#include "base/json/json_writer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using namespace test::api::objects;
@@ -67,4 +68,9 @@ TEST(JsonSchemaCompilerObjectsTest, OnObjectFiredCreate) {
   DictionaryValue* result = NULL;
   ASSERT_TRUE(results->GetDictionary(0, &result));
   ASSERT_TRUE(result->Equals(&expected));
+
+  std::string json1 = OnObjectFired::ToJson(object);
+  std::string json2;
+  base::JSONWriter::Write(results.get(), &json2);
+  ASSERT_EQ(json1, json2);
 }