generated_api.h should have its body generated into generated_api.cc

tools/json_schema_compiler/schema_bundle_generator.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import code
 import cpp_util
 from model import Platforms
 from schema_util import CapitalizeFirstLetter
 from schema_util import JsFunctionNameToClassName
 
@@ skipping 23 matching lines @@
 class SchemaBundleGenerator(object):
   """This class contains methods to generate code based on multiple schemas.
   """
 
   def __init__(self, root, model, api_defs, cpp_type_generator):
     self._root = root;
     self._model = model
     self._api_defs = api_defs
     self._cpp_type_generator = cpp_type_generator
 
   def GenerateHeader(self, file_base, body_code):

[not at google - send to devlin, 2013/02/04 16:57:24]

_GenerateHeader 

     """Generates a code.Code object for a header file
 
     Parameters:
     - |file_base| - the base of the filename, e.g. 'foo' (for 'foo.h')
     - |body_code| - the code to put in between the multiple inclusion guards"""
     c = code.Code()
     c.Append(cpp_util.CHROMIUM_LICENSE)
     c.Append()
     c.Append(cpp_util.GENERATED_BUNDLE_FILE_MESSAGE % SOURCE_BASE_PATH)
     ifndef_name = cpp_util.GenerateIfndefName(SOURCE_BASE_PATH, file_base)
@@ skipping 21 matching lines @@
         raise ValueError("Unsupported platform ifdef: %s" % platform.name)
     return ' and '.join(ifdefs)
 
   def GenerateAPIHeader(self):
     """Generates the header for API registration / declaration"""
     c = code.Code()
 
     c.Append('#include <string>')
     c.Append()
     c.Append('#include "base/basictypes.h"')
+    c.Append()
+    c.Append("class ExtensionFunctionRegistry;")
+    c.Append()
+    c.Concat(self._cpp_type_generator.GetRootNamespaceStart())
+    for namespace in self._model.namespaces.values():
+      c.Append("// TODO(miket): emit code for %s" % (namespace.unix_name))

[not at google - send to devlin, 2013/02/04 16:57:24]

I don't know what this TODO means and it has no bug link, let's delete it.

+    c.Append()
+    c.Sblock('class GeneratedFunctionRegistry {')
+    c.Append(' public:')
+    c.Append('static void RegisterAll('
+                 'ExtensionFunctionRegistry* registry);')

[not at google - send to devlin, 2013/02/04 16:57:24]

C++ indentation here needs fixing (and line above).

+    c.Eblock('};');
+    c.Append()
+    c.Concat(self._cpp_type_generator.GetRootNamespaceEnd())
+    c.Append()
+    return self.GenerateHeader('generated_api', c)
 
+  def GenerateAPICC(self):
+    """Generates a code.Code object for the generated API .cc file"""
+    c = code.Code()
+    c.Append(cpp_util.CHROMIUM_LICENSE)
+    c.Append()
+    c.Append('#include "%s"' % (os.path.join(SOURCE_BASE_PATH,
+                                             'generated_api.h')))
+    c.Append()
     for namespace in self._model.namespaces.values():
       namespace_name = namespace.unix_name.replace("experimental_", "")
       implementation_header = namespace.compiler_options.get(
           "implemented_in",
           "chrome/browser/extensions/api/%s/%s_api.h" % (namespace_name,
                                                          namespace_name))
       if not os.path.exists(
           os.path.join(self._root, os.path.normpath(implementation_header))):
         if "implemented_in" in namespace.compiler_options:
           raise ValueError('Header file for namespace "%s" specified in '
                           'compiler_options not found: %s' %
                           (namespace.unix_name, implementation_header))
         continue
       ifdefs = self._GetPlatformIfdefs(namespace)
       if ifdefs is not None:
         c.Append("#if %s" % ifdefs, indent_level=0)
 
       c.Append('#include "%s"' % implementation_header)
 
       if ifdefs is not None:
         c.Append("#endif  // %s" % ifdefs, indent_level=0)
-
     c.Append()
-    c.Append("class ExtensionFunctionRegistry;")
+    c.Append('#include '
+                 '"chrome/browser/extensions/extension_function_registry.h"')
     c.Append()
-
     c.Concat(self._cpp_type_generator.GetRootNamespaceStart())
-    for namespace in self._model.namespaces.values():
-      c.Append("// TODO(miket): emit code for %s" % (namespace.unix_name))
     c.Append()
-    c.Concat(self.GenerateFunctionRegistry())
+    c.Concat(self.GenerateFunctionRegistryRegisterAll())
+    c.Append()
     c.Concat(self._cpp_type_generator.GetRootNamespaceEnd())
     c.Append()
-    return self.GenerateHeader('generated_api', c)
+    return c
 
   def _GetNamespaceFunctions(self, namespace):
     functions = list(namespace.functions.values())
     if namespace.compiler_options.get("generate_type_functions", False):
       for type_ in namespace.types.values():
         functions += list(type_.functions.values())
     return functions
 
-  def GenerateFunctionRegistry(self):
+  def GenerateFunctionRegistryRegisterAll(self):

[not at google - send to devlin, 2013/02/04 16:57:24]

_GenerateFunctionRegistryRegisterAll

     c = code.Code()
-    c.Sblock("class GeneratedFunctionRegistry {")
-    c.Append(" public:")
-    c.Sblock("static void RegisterAll(ExtensionFunctionRegistry* registry) {")
+    c.Append('// static')
+    c.Sblock('void GeneratedFunctionRegistry::RegisterAll('
+                 'ExtensionFunctionRegistry* registry) {')
     for namespace in self._model.namespaces.values():
       namespace_ifdefs = self._GetPlatformIfdefs(namespace)
       if namespace_ifdefs is not None:
         c.Append("#if %s" % namespace_ifdefs, indent_level=0)
 
       namespace_name = CapitalizeFirstLetter(namespace.name.replace(
           "experimental.", ""))
       for function in self._GetNamespaceFunctions(namespace):
         if function.nocompile:
           continue
         function_ifdefs = self._GetPlatformIfdefs(function)
         if function_ifdefs is not None:
           c.Append("#if %s" % function_ifdefs, indent_level=0)
 
         function_name = JsFunctionNameToClassName(namespace.name, function.name)
         c.Append("registry->RegisterFunction<%sFunction>();" % (
             function_name))
 
         if function_ifdefs is not None:
           c.Append("#endif  // %s" % function_ifdefs, indent_level=0)
 
       if namespace_ifdefs is not None:
         c.Append("#endif  // %s" % namespace_ifdefs, indent_level=0)
     c.Eblock("}")
-    c.Eblock("};")
-    c.Append()
     return c
 
   def GenerateSchemasHeader(self):
     """Generates a code.Code object for the generated schemas .h file"""
     c = code.Code()
     c.Append('#include <map>')
     c.Append('#include <string>')
     c.Append();
     c.Append('#include "base/string_piece.h"')
     c.Append()
@@ skipping 30 matching lines @@
                                 separators=(',', ':'))
       # Escape all double-quotes and backslashes. For this to output a valid
       # JSON C string, we need to escape \ and ".
       json_content = json_content.replace('\\', '\\\\').replace('"', '\\"')
       c.Append('(*schemas)["%s"] = "%s";' % (namespace.name, json_content))
     c.Eblock('}')
     c.Append()
     c.Concat(self._cpp_type_generator.GetRootNamespaceEnd())
     c.Append()
     return c