Make all extension api types fully qualified.

tools/json_schema_compiler/cc_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.
 
 from code import Code
 from model import PropertyType
 import any_helper
 import cpp_util
 import model
+import schema_util
 import sys
 import util_cc_helper
 
 class CCGenerator(object):
   """A .cc generator for a namespace.
   """
   def __init__(self, namespace, cpp_type_generator):
     self._cpp_type_generator = cpp_type_generator
     self._namespace = namespace
     self._target_namespace = (
@@ skipping 44 matching lines @@
             nodoc=True)
         if property_code:
           c.Concat(property_code).Append()
     if self._namespace.types:
       (c.Append('//')
         .Append('// Types')
         .Append('//')
         .Append()
       )
     for type_ in self._namespace.types.values():
-      (c.Concat(self._GenerateType(type_.name, type_))
-        .Append()
+      (c.Concat(self._GenerateType(
+        schema_util.StripSchemaNamespace(type_.name), type_)).Append()
       )
     if self._namespace.functions:
       (c.Append('//')
         .Append('// Functions')
         .Append('//')
         .Append()
       )
     for function in self._namespace.functions.values():
       (c.Concat(self._GenerateFunction(
           cpp_util.Classname(function.name), function))
         .Append()
       )
     (c.Concat(self._cpp_type_generator.GetNamespaceEnd())
       .Concat(self._cpp_type_generator.GetRootNamespaceEnd())
       .Append()
     )
     # TODO(calamity): Events
     return c
 
   def _GenerateType(self, cpp_namespace, type_):
     """Generates the function definitions for a type.
     """
-    classname = cpp_util.Classname(type_.name)
+    classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name))
     c = Code()
 
     if type_.functions:
       # Types with functions are not instantiable in C++ because they are
       # handled in pure Javascript and hence have no properties or
       # additionalProperties.
       if type_.properties:
         raise NotImplementedError('\n'.join(model.GetModelHierarchy(type_)) +
             '\nCannot generate both functions and properties on a type')
       for function in type_.functions.values():
@@ skipping 58 matching lines @@
     else:
       s = ''
     s = s + ' {}'
     return Code().Append(s)
 
   def _GenerateTypePopulate(self, cpp_namespace, type_):
     """Generates the function for populating a type given a pointer to it.
 
     E.g for type "Foo", generates Foo::Populate()
     """
-    classname = cpp_util.Classname(type_.name)
+    classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name))
     c = Code()
     (c.Append('// static')
       .Sblock('bool %(namespace)s::Populate'
               '(const Value& value, %(name)s* out) {')
         .Append('if (!value.IsType(Value::TYPE_DICTIONARY))')
         .Append('  return false;')
     )
     if type_.properties:
       (c.Append('const DictionaryValue* dict = '
                 'static_cast<const DictionaryValue*>(&value);')
@@ skipping 471 matching lines @@
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_ ==
         PropertyType.ARRAY)
 
   def _IsFundamentalOrFundamentalRef(self, prop):
     """Determines if this property is a Fundamental type or is a ref to a
     Fundamental type.
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_.
         is_fundamental)