Add an implementation path option to json_schema_compiler

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,
-               source_file_dir):
+               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
 
     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:
@@ skipping 116 matching lines @@
     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",
-          "chrome/browser/extensions/api/%s/%s_api.h" % (namespace_name,
-                                                         namespace_name))
+          "%s/%s/%s_api.h" % (self._bundle._impl_dir,
+                              namespace_name,
+                              namespace_name))
       if not os.path.exists(
           os.path.join(self._bundle._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._bundle._GetPlatformIfdefs(namespace)
       if ifdefs is not None:
@@ skipping 101 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