JSON schema compiler: remove SOURCE_BASE_PATH hack from bundle generator.

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
 
 import json
 import os
 import re
 
-# TODO(miket/asargent) - parameterize this.
-SOURCE_BASE_PATH = 'chrome/common/extensions/api'
 
 def _RemoveDescriptions(node):
   """Returns a copy of |schema| with "description" fields removed.
   """
   if isinstance(node, dict):
     result = {}
     for key, value in node.items():
       # Some schemas actually have properties called "description", so only
       # remove descriptions that have string values.
       if key == 'description' and isinstance(value, basestring):
         continue
       result[key] = _RemoveDescriptions(value)
     return result
   if isinstance(node, list):
     return [_RemoveDescriptions(v) for v in node]
   return node
 
 
 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):
+  def __init__(self,
+               root,
+               model,
+               api_defs,
+               cpp_type_generator,
+               cpp_namespace,
+               source_file_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.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 % SOURCE_BASE_PATH)
-    ifndef_name = cpp_util.GenerateIfndefName(SOURCE_BASE_PATH, file_base)
+    c.Append(cpp_util.GENERATED_BUNDLE_FILE_MESSAGE % self._source_file_dir)
+    ifndef_name = cpp_util.GenerateIfndefName(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 86 matching lines @@
 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):
     c = code.Code()
     c.Append(cpp_util.CHROMIUM_LICENSE)
     c.Append()
-    c.Append('#include "%s"' % (os.path.join(SOURCE_BASE_PATH,
+    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))
       if not os.path.exists(
           os.path.join(self._bundle._root,
@@ skipping 62 matching lines @@
 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):
     c = code.Code()
     c.Append(cpp_util.CHROMIUM_LICENSE)
     c.Append()
-    c.Append('#include "%s"' % (os.path.join(SOURCE_BASE_PATH,
+    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:
       namespace = self._bundle._model.namespaces[api.get('namespace')]
       # JSON parsing code expects lists of schemas, so dump a singleton list.
       json_content = json.dumps([_RemoveDescriptions(api)],
                                 separators=(',', ':'))
@@ skipping 26 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