Make the root_namespace argument to json_schema_compiler.gypi a string

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 21 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,
+               cpp_namespace_pattern,
                source_file_dir,
                impl_dir):
     self._root = root
     self._model = model
     self._api_defs = api_defs
     self._cpp_type_generator = cpp_type_generator
-    self._cpp_namespace = cpp_namespace
     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)
     self.schemas_cc_generator = _SchemasCCGenerator(self)
     self.schemas_h_generator = _SchemasHGenerator(self)
 
   def _GenerateHeader(self, file_base, body_code):
     """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 % self._source_file_dir)
-    ifndef_name = cpp_util.GenerateIfndefName(self._source_file_dir, file_base)
+    ifndef_name = cpp_util.GenerateIfndefName(
+        '%s/%s.h' % (self._source_file_dir, file_base))
     c.Append()
     c.Append('#ifndef %s' % ifndef_name)
     c.Append('#define %s' % ifndef_name)
     c.Append()
     c.Concat(body_code)
     c.Append()
     c.Append('#endif  // %s' % ifndef_name)
     c.Append()
     return c
 
@@ skipping 61 matching lines @@
         c.Append("#endif  // %s" % namespace_ifdefs, indent_level=0)
     c.Eblock("}")
     return c
 
 
 class _APIHGenerator(object):
   """Generates the header for API registration / declaration"""
   def __init__(self, cpp_bundle):
     self._bundle = cpp_bundle
 
-  def Generate(self, namespace):
+  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.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):
   """Generates a code.Code object for the generated API .cc file"""
 
   def __init__(self, cpp_bundle):
     self._bundle = cpp_bundle
 
-  def Generate(self, namespace):
+  def Generate(self, _):  # namespace not relevant, this is a bundle
     c = code.Code()
     c.Append(cpp_util.CHROMIUM_LICENSE)
     c.Append()
     c.Append('#include "%s"' % (os.path.join(self._bundle._source_file_dir,
                                              'generated_api.h')))
     c.Append()
     for namespace in self._bundle._model.namespaces.values():
       namespace_name = namespace.unix_name.replace("experimental_", "")
       implementation_header = namespace.compiler_options.get(
           "implemented_in",
@@ skipping 27 matching lines @@
     c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
     c.Append()
     return c
 
 
 class _SchemasHGenerator(object):
   """Generates a code.Code object for the generated schemas .h file"""
   def __init__(self, cpp_bundle):
     self._bundle = cpp_bundle
 
-  def Generate(self, namespace):
+  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.Sblock(' public:')
@@ skipping 15 matching lines @@
                         lambda m: m.group(0)[1].upper(),
                         name.replace('.', '_'))
 
 
 class _SchemasCCGenerator(object):
   """Generates a code.Code object for the generated schemas .cc file"""
 
   def __init__(self, cpp_bundle):
     self._bundle = cpp_bundle
 
-  def Generate(self, namespace):
+  def Generate(self, _):  # namespace not relevant, this is a bundle
     c = code.Code()
     c.Append(cpp_util.CHROMIUM_LICENSE)
     c.Append()
     c.Append('#include "%s"' % (os.path.join(self._bundle._source_file_dir,
                                              'generated_schemas.h')))
     c.Append()
     c.Append('#include "base/lazy_instance.h"')
     c.Append()
     c.Append('namespace {')
     for api in self._bundle._api_defs:
@@ skipping 35 matching lines @@
     c.Eblock('}')
     c.Append()
     c.Append('// static')
     c.Sblock('bool GeneratedSchemas::IsGenerated(std::string name) {')
     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