[Extensions] Prefix extension apis in the generation step

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 collections
 import copy
 import json
 import os
 import re
 
 
 def _RemoveKey(node, key, type_restriction):
   if isinstance(node, dict):
     if key in node and isinstance(node[key], type_restriction):
       del node[key]
     for value in node.values():
       _RemoveKey(value, key, type_restriction)
   elif isinstance(node, list):
     for value in node:
       _RemoveKey(value, key, type_restriction)
 
 def _RemoveUnneededFields(schema):
   """Returns a copy of |schema| with fields that aren't necessary at runtime
   removed.
   """
   # Return a copy so that we don't pollute the global api object, which may be
   # used elsewhere.
   ret = copy.deepcopy(schema)
   _RemoveKey(ret, "description", basestring)
   _RemoveKey(ret, "compiler_options", dict)
   _RemoveKey(ret, "nodoc", bool)
   _RemoveKey(ret, "noinline_doc", bool)
   return ret
 
+def _PrefixSchemaWithNamespace(schema):
+  """Modifies |schema| in place to prefix all types and references with a
+  namespace, if they aren't already qualified. That is, in the tabs API, this
+  will turn type Tab into tabs.Tab, but will leave the fully-qualified
+  windows.Window as-is.
+  """
+  assert isinstance(schema, dict), "Schema is unexpected type"
+  namespace = schema['namespace']
+  def prefix(obj, key, mandatory):
+    if not key in obj:
+      assert not mandatory, (
+             'Required key "%s" is not present in object.' % key)
+      return
+    assert type(obj[key]) in [str, unicode]
+    if obj[key].find('.') == -1:
+      obj[key] = '%s.%s' % (namespace, obj[key])
+
+  if 'types' in schema:
+    assert isinstance(schema['types'], list)
+    for t in schema['types']:
+      assert isinstance(t, dict), "Type entry is unexpected type"
+      prefix(t, 'id', True)
+      prefix(t, 'customBindings', False)
+
+  def prefix_refs(val):
+    if type(val) is list:
+      for sub_val in val:
+        prefix_refs(sub_val)
+    elif type(val) is dict or type(val) is collections.OrderedDict:
+      prefix(val, '$ref', False)
+      for key, sub_val in val.items():
+        prefix_refs(sub_val)
+  prefix_refs(schema)
+  return schema
+
 
 class CppBundleGenerator(object):
   """This class contains methods to generate code based on multiple schemas.
   """
 
   def __init__(self,
                root,
                model,
                api_defs,
                cpp_type_generator,
@@ skipping 234 matching lines @@
     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:
       namespace = self._bundle._model.namespaces[api.get('namespace')]
       # JSON parsing code expects lists of schemas, so dump a singleton list.
-      json_content = json.dumps([_RemoveUnneededFields(api)],
+      json_content = json.dumps([_PrefixSchemaWithNamespace(
+                                     _RemoveUnneededFields(api))],
                                 separators=(',', ':'))
       # 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";' %
@@ skipping 25 matching lines @@
     c.Append()
     c.Append('// static')
     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