Generate all extension schema namespaces as "api" and instead vary the generated bundle names.

tools/json_schema_compiler/cpp_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 22 matching lines @@
 class CppBundleGenerator(object):
   """This class contains methods to generate code based on multiple schemas.
   """
 
   def __init__(self,
                root,
                model,
                api_defs,
                cpp_type_generator,
                cpp_namespace_pattern,
+               bundle_name,
                source_file_dir,
                impl_dir):
     self._root = root
     self._model = model
     self._api_defs = api_defs
     self._cpp_type_generator = cpp_type_generator
+    self._bundle_name = bundle_name
     self._source_file_dir = source_file_dir
     self._impl_dir = impl_dir
 
     # Hack: assume that the C++ namespace for the bundle is the namespace of the
     # files without the last component of the namespace. A cleaner way to do
     # this would be to make it a separate variable in the gyp file.
     self._cpp_namespace = cpp_namespace_pattern.rsplit('::', 1)[0]
 
     self.api_cc_generator = _APICCGenerator(self)
     self.api_h_generator = _APIHGenerator(self)
@@ skipping 52 matching lines @@
     c.Append("registry->RegisterFunction<%sFunction>();" % (
         function_name))
 
     if function_ifdefs is not None:
       c.Append("#endif  // %s" % function_ifdefs, indent_level=0)
     return c
 
   def _GenerateFunctionRegistryRegisterAll(self):
     c = code.Code()
     c.Append('// static')
-    c.Sblock('void GeneratedFunctionRegistry::RegisterAll('
-                 'ExtensionFunctionRegistry* registry) {')
+    c.Sblock('void %s::RegisterAll(ExtensionFunctionRegistry* registry) {' %
+             self._GenerateBundleClass('GeneratedFunctionRegistry'))
     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)
 
       for function in namespace.functions.values():
         if function.nocompile:
           continue
         c.Concat(self._GenerateRegisterFunctions(namespace.name, function))
 
       for type_ in namespace.types.values():
         for function in type_.functions.values():
           if function.nocompile:
             continue
           namespace_types_name = JsFunctionNameToClassName(
                 namespace.name, type_.name)
           c.Concat(self._GenerateRegisterFunctions(namespace_types_name,
                                                    function))
 
       if namespace_ifdefs is not None:
         c.Append("#endif  // %s" % namespace_ifdefs, indent_level=0)
     c.Eblock("}")
     return c
 
+  def _GenerateBundleClass(self, class_name):
+    '''Generates the C++ class name to use for a bundle class, taking into
+    account the bundle's name.
+    '''
+    return self._bundle_name + class_name
+
 
 class _APIHGenerator(object):
   """Generates the header for API registration / declaration"""
   def __init__(self, cpp_bundle):
     self._bundle = cpp_bundle
 
   def Generate(self, _):  # namespace not relevant, this is a bundle
     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(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
     c.Append()
-    c.Append('class GeneratedFunctionRegistry {')
+    c.Append('class %s {' %
+             self._bundle._GenerateBundleClass('GeneratedFunctionRegistry'))
     c.Sblock(' public:')
     c.Append('static void RegisterAll('
                  'ExtensionFunctionRegistry* registry);')
     c.Eblock('};')
     c.Append()
     c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
     return self._bundle._GenerateHeader('generated_api', c)
 
 
 class _APICCGenerator(object):
@@ skipping 53 matching lines @@
 
   def Generate(self, _):  # namespace not relevant, this is a bundle
     c = code.Code()
     c.Append('#include <map>')
     c.Append('#include <string>')
     c.Append()
     c.Append('#include "base/strings/string_piece.h"')
     c.Append()
     c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
     c.Append()
-    c.Append('class GeneratedSchemas {')
+    c.Append('class %s {' %
+             self._bundle._GenerateBundleClass('GeneratedSchemas'))
     c.Sblock(' public:')
     c.Append('// Determines if schema named |name| is generated.')
     c.Append('static bool IsGenerated(std::string name);')
     c.Append()
     c.Append('// Gets the API schema named |name|.')
     c.Append('static base::StringPiece Get(const std::string& name);')
     c.Eblock('};')
     c.Append()
     c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
     return self._bundle._GenerateHeader('generated_schemas', c)
@@ skipping 31 matching lines @@
       # Escape all double-quotes and backslashes. For this to output a valid
       # JSON C string, we need to escape \ and ". Note that some schemas are
       # too large to compile on windows. Split the JSON up into several
       # strings, since apparently that helps.
       max_length = 8192
       segments = [json_content[i:i + max_length].replace('\\', '\\\\')
                                                 .replace('"', '\\"')
                   for i in xrange(0, len(json_content), max_length)]
       c.Append('const char %s[] = "%s";' %
           (_FormatNameAsConstant(namespace.name), '" "'.join(segments)))
-    c.Append('}')
-    c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
     c.Append()
     c.Sblock('struct Static {')
     c.Sblock('Static() {')
     for api in self._bundle._api_defs:
       namespace = self._bundle._model.namespaces[api.get('namespace')]
       c.Append('schemas["%s"] = %s;' % (namespace.name,
                                         _FormatNameAsConstant(namespace.name)))
     c.Eblock('}')
     c.Append()
     c.Append('std::map<std::string, const char*> schemas;')
     c.Eblock('};')
     c.Append()
     c.Append('base::LazyInstance<Static> g_lazy_instance;')
     c.Append()
+    c.Append('}  // namespace')
+    c.Append()
+    c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
+    c.Append()
     c.Append('// static')
-    c.Sblock('base::StringPiece GeneratedSchemas::Get('
-                  'const std::string& name) {')
+    c.Sblock('base::StringPiece %s::Get(const std::string& name) {' %
+             self._bundle._GenerateBundleClass('GeneratedSchemas'))
     c.Append('return IsGenerated(name) ? '
              'g_lazy_instance.Get().schemas[name] : "";')
     c.Eblock('}')
     c.Append()
     c.Append('// static')
-    c.Sblock('bool GeneratedSchemas::IsGenerated(std::string name) {')
+    c.Sblock('bool %s::IsGenerated(std::string name) {' %
+             self._bundle._GenerateBundleClass('GeneratedSchemas'))
     c.Append('return g_lazy_instance.Get().schemas.count(name) > 0;')
     c.Eblock('}')
     c.Append()
     c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
     c.Append()
     return c