Switch the downloads API over to IDL/json_schema_compiler

tools/json_schema_compiler/h_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 cpp_util
-import model
-import os
 import schema_util
 
 class HGenerator(object):
   """A .h generator for a namespace.
   """
   def __init__(self, namespace, cpp_type_generator):
     self._cpp_type_generator = cpp_type_generator
     self._namespace = namespace
     self._target_namespace = (
         self._cpp_type_generator.GetCppNamespaceName(self._namespace))
@@ skipping 84 matching lines @@
     """Generates the list of types in the current namespace in an order in which
     depended-upon types appear before types which depend on them.
     """
     dependency_order = []
 
     def ExpandType(path, type_):
       if type_ in path:
         raise ValueError("Illegal circular dependency via cycle " +
                          ", ".join(map(lambda x: x.name, path + [type_])))
       for prop in type_.properties.values():
-        if not prop.optional and prop.type_ == PropertyType.REF:
+        if (prop.type_ == PropertyType.REF and
+            schema_util.GetNamespace(prop.ref_type) == self._namespace.name):
           ExpandType(path + [type_], self._namespace.types[prop.ref_type])
       if not type_ in dependency_order:
         dependency_order.append(type_)
 
     for type_ in self._namespace.types.values():
       ExpandType([], type_)
     return dependency_order
 
   def _GenerateEnumDeclaration(self, enum_name, prop, values):
     """Generate the declaration of a C++ enum for the given property and
@@ skipping 46 matching lines @@
       if type_.description:
         c.Comment(type_.description)
       c.Append('typedef std::vector<%(item_type)s> %(classname)s;')
       c.Substitute({'classname': classname, 'item_type':
           self._cpp_type_generator.GetType(type_.item_type,
                                            wrap_optional=True)})
     elif type_.type_ == PropertyType.STRING:
       if type_.description:
         c.Comment(type_.description)
       c.Append('typedef std::string %(classname)s;')
-      c.Substitute({'classname': classname})
     else:
       if type_.description:
         c.Comment(type_.description)
       (c.Sblock('struct %(classname)s {')
           .Append('~%(classname)s();')
           .Append('%(classname)s();')
           .Append()
           .Concat(self._GeneratePropertyStructures(type_.properties.values()))
           .Concat(self._GenerateFields(type_.properties.values()))
       )
       if type_.from_json:
-        (c.Comment('Populates a %s object from a Value. Returns'
+        (c.Comment('Populates a %s object from a base::Value. Returns'
                    ' whether |out| was successfully populated.' % classname)
-          .Append(
-              'static bool Populate(const Value& value, %(classname)s* out);')
+          .Append('static bool Populate(const base::Value& value, '
+                  '%(classname)s* out);')
           .Append()
         )
 
       if type_.from_client:
-        (c.Comment('Returns a new DictionaryValue representing the'
+        (c.Comment('Returns a new base::DictionaryValue representing the'
                    ' serialized form of this %s object. Passes '
                    'ownership to caller.' % classname)
-          .Append('scoped_ptr<DictionaryValue> ToValue() const;')
+          .Append('scoped_ptr<base::DictionaryValue> ToValue() const;')
         )
 
       (c.Eblock()
         .Sblock(' private:')
           .Append('DISALLOW_COPY_AND_ASSIGN(%(classname)s);')
         .Eblock('};')
       )
     c.Substitute({'classname': classname})
     return c
 
@@ skipping 17 matching lines @@
     """Generates the struct for passing parameters into a function.
     """
     c = Code()
 
     if function.params:
       (c.Sblock('struct Params {')
           .Concat(self._GeneratePropertyStructures(function.params))
           .Concat(self._GenerateFields(function.params))
           .Append('~Params();')
           .Append()
-          .Append('static scoped_ptr<Params> Create(const ListValue& args);')
+          .Append('static scoped_ptr<Params> Create('
+                  'const base::ListValue& args);')
         .Eblock()
         .Sblock(' private:')
           .Append('Params();')
           .Append()
           .Append('DISALLOW_COPY_AND_ASSIGN(Params);')
         .Eblock('};')
       )
 
     return c
 
@@ skipping 14 matching lines @@
             self._cpp_type_generator.GetChoicesEnumType(prop),
             prop,
             [choice.type_.name for choice in prop.choices.values()]))
         c.Concat(self._GeneratePropertyStructures(prop.choices.values()))
       elif prop.type_ == PropertyType.ENUM:
         enum_name = self._cpp_type_generator.GetType(prop)
         c.Concat(self._GenerateEnumDeclaration(
             enum_name,
             prop,
             prop.enum_values))
-        c.Append('static scoped_ptr<Value> CreateEnumValue(%s %s);' %
+        c.Append('static scoped_ptr<base::Value> CreateEnumValue(%s %s);' %
             (enum_name, prop.unix_name))
     return c
 
   def _GenerateFunctionResult(self, function):
     """Generates functions for passing a function's result back.
     """
     c = Code()
 
     c.Sblock('namespace Result {')
     params = function.callback.params
     if not params:
-      c.Append('Value* Create();')
+      c.Append('base::Value* Create();')
     else:
       c.Concat(self._GeneratePropertyStructures(params))
 
       # If there is a single parameter, this is straightforward. However, if
       # the callback parameter is of 'choices', this generates a Create method
       # for each choice. This works because only 1 choice can be returned at a
       # time.
       for param in self._cpp_type_generator.GetExpandedChoicesInParams(params):
         if param.description:
           c.Comment(param.description)
         if param.type_ == PropertyType.ANY:
-          c.Comment("Value* Result::Create(Value*) not generated "
+          c.Comment("base::Value* Result::Create(base::Value*) not generated "
                     "because it's redundant.")
           continue
-        c.Append('Value* Create(const %s);' % cpp_util.GetParameterDeclaration(
-            param, self._cpp_type_generator.GetType(param)))
+        c.Append('base::Value* Create(const %s);' %
+                 cpp_util.GetParameterDeclaration(
+                     param, self._cpp_type_generator.GetType(param)))
     c.Eblock('};')
 
     return c