Switch the downloads API over to IDL/json_schema_compiler

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
@@ skipping 24 matching lines @@
       .Append('#include "%s/%s.h"' %
           (self._namespace.source_file_dir, self._namespace.unix_name))
     )
     includes = self._cpp_type_generator.GenerateIncludes()
     if not includes.IsEmpty():
       (c.Concat(includes)
         .Append()
       )
 
     (c.Append()
-      .Append('using base::Value;')
-      .Append('using base::DictionaryValue;')
-      .Append('using base::ListValue;')
-      .Append('using base::BinaryValue;')
-      .Append('using %s;' % any_helper.ANY_CLASS)
-      .Append()
       .Concat(self._cpp_type_generator.GetRootNamespaceStart())
       .Concat(self._cpp_type_generator.GetNamespaceStart())
       .Append()
     )
     if self._namespace.properties:
       (c.Append('//')
         .Append('// Properties')
         .Append('//')
         .Append()
       )
@@ skipping 105 matching lines @@
 
   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(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))')
+              '(const base::Value& value, %(name)s* out) {')
+        .Append('if (!value.IsType(base::Value::TYPE_DICTIONARY))')
         .Append('  return false;')
     )
     if type_.properties:
-      (c.Append('const DictionaryValue* dict = '
-                'static_cast<const DictionaryValue*>(&value);')
+      (c.Append('const base::DictionaryValue* dict = '
+                'static_cast<const base::DictionaryValue*>(&value);')
         .Append()
       )
       for prop in type_.properties.values():
         c.Concat(self._InitializePropertyToDefault(prop, 'out'))
       for prop in type_.properties.values():
         if prop.type_ == PropertyType.ADDITIONAL_PROPERTIES:
           c.Append('out->additional_properties.MergeDictionary(dict);')
           # remove all keys that are actual properties
           for cur_prop in type_.properties.values():
             if prop != cur_prop:
               c.Append('out->additional_properties'
                   '.RemoveWithoutPathExpansion("%s", NULL);' % cur_prop.name)
           c.Append()
         else:
           c.Concat(self._GenerateTypePopulateProperty(prop, 'dict', 'out'))
     (c.Append('return true;')
       .Eblock('}')
     )
     c.Substitute({'namespace': cpp_namespace, 'name': classname})
     return c
 
   def _GenerateTypePopulateProperty(self, prop, src, dst):
     """Generate the code to populate a single property in a type.
 
-    src: DictionaryValue*
+    src: base::DictionaryValue*
     dst: Type*
     """
     c = Code()
     value_var = prop.unix_name + '_value'
-    c.Append('Value* %(value_var)s = NULL;')
+    c.Append('base::Value* %(value_var)s = NULL;')
     if prop.optional:
       (c.Sblock(
           'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {'
         )
         .Concat(self._GeneratePopulatePropertyFromValue(
             prop, value_var, dst, 'false'))
         .Eblock('}')
       )
     else:
       (c.Append(
           'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s))')
         .Append('  return false;')
         .Concat(self._GeneratePopulatePropertyFromValue(
             prop, value_var, dst, 'false'))
       )
     c.Append()
     c.Substitute({'value_var': value_var, 'key': prop.name, 'src': src})
     return c
 
   def _GenerateTypeToValue(self, cpp_namespace, type_):
-    """Generates a function that serializes the type into a |DictionaryValue|.
+    """Generates a function that serializes the type into a
+    |base::DictionaryValue|.
 
     E.g. for type "Foo" generates Foo::ToValue()
     """
     c = Code()
-    (c.Sblock('scoped_ptr<DictionaryValue> %s::ToValue() const {' %
+    (c.Sblock('scoped_ptr<base::DictionaryValue> %s::ToValue() const {' %
           cpp_namespace)
-        .Append('scoped_ptr<DictionaryValue> value(new DictionaryValue());')
+        .Append('scoped_ptr<base::DictionaryValue> value('
+                'new base::DictionaryValue());')
         .Append()
     )
     for prop in type_.properties.values():
       if prop.type_ == PropertyType.ADDITIONAL_PROPERTIES:
         c.Append('value->MergeDictionary(&%s);' % prop.unix_name)
       else:
         if prop.optional:
           if prop.type_ == PropertyType.ENUM:
             c.Sblock('if (%s != %s)' %
                 (prop.unix_name,
@@ skipping 29 matching lines @@
 
     # Result::Create function
     if function.callback:
       c.Concat(self._GenerateFunctionResultCreate(cpp_namespace, function))
 
     c.Substitute({'cpp_namespace': cpp_namespace})
 
     return c
 
   def _GenerateCreateEnumValue(self, cpp_namespace, prop):
-    """Generates CreateEnumValue() that returns the |StringValue|
+    """Generates CreateEnumValue() that returns the |base::StringValue|
     representation of an enum.
     """
     c = Code()
     c.Append('// static')
-    c.Sblock('scoped_ptr<Value> %(cpp_namespace)s::CreateEnumValue(%(arg)s) {')
+    c.Sblock('scoped_ptr<base::Value> %(cpp_namespace)s::CreateEnumValue('
+             '%(arg)s) {')
     c.Sblock('switch (%s) {' % prop.unix_name)
     if prop.optional:
       (c.Append('case %s: {' % self._cpp_type_generator.GetEnumNoneValue(prop))
-        .Append('  return scoped_ptr<Value>();')
+        .Append('  return scoped_ptr<base::Value>();')
         .Append('}')
       )
     for enum_value in prop.enum_values:
       (c.Append('case %s: {' %
           self._cpp_type_generator.GetEnumValue(prop, enum_value))
-        .Append('  return scoped_ptr<Value>(Value::CreateStringValue("%s"));' %
-            enum_value)
+        .Append('  return scoped_ptr<base::Value>('
+                'base::Value::CreateStringValue("%s"));' %
+                enum_value)
         .Append('}')
       )
     (c.Append('default: {')
-      .Append('  return scoped_ptr<Value>();')
+      .Append('  return scoped_ptr<base::Value>();')
       .Append('}')
     )
     c.Eblock('}')
     c.Eblock('}')
     c.Substitute({
         'cpp_namespace': cpp_namespace,
         'arg': cpp_util.GetParameterDeclaration(
             prop, self._cpp_type_generator.GetType(prop))
     })
     return c
 
   def _CreateValueFromProperty(self, prop, var):
-    """Creates a Value given a property. Generated code passes ownership
+    """Creates a base::Value given a property. Generated code passes ownership
     to caller.
 
     var: variable or variable*
 
-    E.g for std::string, generate Value::CreateStringValue(var)
+    E.g for std::string, generate base::Value::CreateStringValue(var)
     """
     if prop.type_ == PropertyType.CHOICES:
       # CHOICES conversion not implemented. If needed, write something to
-      # generate a function that returns a scoped_ptr<Value> and put it in
+      # generate a function that returns a scoped_ptr<base::Value> and put it in
       # _GeneratePropertyFunctions, then use it here. Look at CreateEnumValue()
       # for reference.
       raise NotImplementedError(
-          'Conversion of CHOICES to Value not implemented')
+          'Conversion of CHOICES to base::Value not implemented')
     if self._IsObjectOrObjectRef(prop):
       if prop.optional:
         return '%s->ToValue().release()' % var
       else:
         return '%s.ToValue().release()' % var
     elif prop.type_ == PropertyType.ANY:
       return '%s.DeepCopy()' % self._any_helper.GetValue(prop, var)
     elif prop.type_ == PropertyType.ADDITIONAL_PROPERTIES:
       return '%s.DeepCopy()' % var
     elif prop.type_ == PropertyType.ENUM:
       return 'CreateEnumValue(%s).release()' % var
     elif prop.type_ == PropertyType.BINARY:
       return '%s->DeepCopy()' % var
     elif self._IsArrayOrArrayRef(prop):
       return '%s.release()' % self._util_cc_helper.CreateValueFromArray(
           self._cpp_type_generator.GetReferencedProperty(prop), var,
           prop.optional)
     elif self._IsFundamentalOrFundamentalRef(prop):
       if prop.optional:
         var = '*' + var
       prop = self._cpp_type_generator.GetReferencedProperty(prop);
       return {
-          PropertyType.STRING: 'Value::CreateStringValue(%s)',
-          PropertyType.BOOLEAN: 'Value::CreateBooleanValue(%s)',
-          PropertyType.INTEGER: 'Value::CreateIntegerValue(%s)',
-          PropertyType.DOUBLE: 'Value::CreateDoubleValue(%s)',
+          PropertyType.STRING: 'base::Value::CreateStringValue(%s)',
+          PropertyType.BOOLEAN: 'base::Value::CreateBooleanValue(%s)',
+          PropertyType.INTEGER: 'base::Value::CreateIntegerValue(%s)',
+          PropertyType.DOUBLE: 'base::Value::CreateDoubleValue(%s)',
       }[prop.type_] % var
     else:
-      raise NotImplementedError('Conversion of %s to Value not '
+      raise NotImplementedError('Conversion of %s to base::Value not '
           'implemented' % repr(prop.type_))
 
   def _GenerateParamsCheck(self, function, var):
     """Generates a check for the correct number of arguments when creating
     Params.
     """
     c = Code()
     num_required = 0
     for param in function.params:
       if not param.optional:
         num_required += 1
     if num_required == len(function.params):
       c.Append('if (%(var)s.GetSize() != %(total)d)')
     elif not num_required:
       c.Append('if (%(var)s.GetSize() > %(total)d)')
     else:
       c.Append('if (%(var)s.GetSize() < %(required)d'
           ' || %(var)s.GetSize() > %(total)d)')
     c.Append('  return scoped_ptr<Params>();')
     c.Substitute({
         'var': var,
         'required': num_required,
         'total': len(function.params),
     })
     return c
 
   def _GenerateFunctionParamsCreate(self, cpp_namespace, function):
     """Generate function to create an instance of Params. The generated
-    function takes a ListValue of arguments.
+    function takes a base::ListValue of arguments.
 
     E.g for function "Bar", generate Bar::Params::Create()
     """
     c = Code()
     (c.Append('// static')
       .Sblock('scoped_ptr<%(cpp_namespace)s::Params> '
-        '%(cpp_namespace)s::Params::Create(const ListValue& args) {')
+        '%(cpp_namespace)s::Params::Create(const base::ListValue& args) {')
       .Concat(self._GenerateParamsCheck(function, 'args'))
       .Append('scoped_ptr<Params> params(new Params());')
     )
     c.Substitute({'cpp_namespace': cpp_namespace})
 
     for param in function.params:
       c.Concat(self._InitializePropertyToDefault(param, 'params'))
 
     for i, param in enumerate(function.params):
       # Any failure will cause this function to return. If any argument is
       # incorrect or missing, those following it are not processed. Note that
       # for optional arguments, we allow missing arguments and proceed because
       # there may be other arguments following it.
       failure_value = 'scoped_ptr<Params>()'
       c.Append()
       value_var = param.unix_name + '_value'
-      (c.Append('Value* %(value_var)s = NULL;')
-        .Append('if (args.Get(%(i)s, &%(value_var)s) && '
-            '!%(value_var)s->IsType(Value::TYPE_NULL))')
+      (c.Append('base::Value* %(value_var)s = NULL;')
+        .Append('if (args.Get(%(i)s, &%(value_var)s) &&\n'
+                '    !%(value_var)s->IsType(base::Value::TYPE_NULL))')
         .Sblock('{')
         .Concat(self._GeneratePopulatePropertyFromValue(
             param, value_var, 'params', failure_value))
         .Eblock('}')
       )
       if not param.optional:
         (c.Sblock('else {')
           .Append('return %s;' % failure_value)
           .Eblock('}')
         )
       c.Substitute({'value_var': value_var, 'i': i})
     (c.Append()
       .Append('return params.Pass();')
       .Eblock('}')
       .Append()
     )
 
     return c
 
   def _GeneratePopulatePropertyFromValue(
       self, prop, value_var, dst, failure_value, check_type=True):
-    """Generates code to populate a model.Property given a Value*. The
-    existence of data inside the Value* is assumed so checks for existence
+    """Generates code to populate a model.Property given a base::Value*. The
+    existence of data inside the base::Value* is assumed so checks for existence
     should be performed before the code this generates.
 
     prop: the property the code is populating.
-    value_var: a Value* that should represent |prop|.
+    value_var: a base::Value* that should represent |prop|.
     dst: the object with |prop| as a member.
     failure_value: the value to return if |prop| cannot be extracted from
     |value_var|
-    check_type: if true, will check if |value_var| is the correct Value::Type
+    check_type: if true, will check if |value_var| is the correct
+    base::Value::Type
     """
     c = Code()
     c.Sblock('{')
 
     if self._IsFundamentalOrFundamentalRef(prop):
       if prop.optional:
         (c.Append('%(ctype)s temp;')
           .Append('if (!%s)' %
               cpp_util.GetAsFundamentalValue(
                   self._cpp_type_generator.GetReferencedProperty(prop),
                   value_var,
                   '&temp'))
           .Append('  return %(failure_value)s;')
           .Append('%(dst)s->%(name)s.reset(new %(ctype)s(temp));')
         )
       else:
         (c.Append('if (!%s)' %
             cpp_util.GetAsFundamentalValue(
                 self._cpp_type_generator.GetReferencedProperty(prop),
                 value_var,
                 '&%s->%s' % (dst, prop.unix_name)))
           .Append('  return %(failure_value)s;')
         )
     elif self._IsObjectOrObjectRef(prop):
       if prop.optional:
-        (c.Append('DictionaryValue* dictionary = NULL;')
+        (c.Append('base::DictionaryValue* dictionary = NULL;')
           .Append('if (!%(value_var)s->GetAsDictionary(&dictionary))')
           .Append('  return %(failure_value)s;')
           .Append('scoped_ptr<%(ctype)s> temp(new %(ctype)s());')
           .Append('if (!%(ctype)s::Populate(*dictionary, temp.get()))')
           .Append('  return %(failure_value)s;')
           .Append('%(dst)s->%(name)s = temp.Pass();')
         )
       else:
-        (c.Append('DictionaryValue* dictionary = NULL;')
+        (c.Append('base::DictionaryValue* dictionary = NULL;')
           .Append('if (!%(value_var)s->GetAsDictionary(&dictionary))')
           .Append('  return %(failure_value)s;')
           .Append(
               'if (!%(ctype)s::Populate(*dictionary, &%(dst)s->%(name)s))')
           .Append('  return %(failure_value)s;')
         )
     elif prop.type_ == PropertyType.ANY:
       if prop.optional:
-        c.Append('%(dst)s->%(name)s.reset(new Any());')
+        c.Append('%(dst)s->%(name)s.reset(new ' + any_helper.ANY_CLASS + '());')
       c.Append(self._any_helper.Init(prop, value_var, dst) + ';')
     elif self._IsArrayOrArrayRef(prop):
       # util_cc_helper deals with optional and required arrays
-      (c.Append('ListValue* list = NULL;')
+      (c.Append('base::ListValue* list = NULL;')
         .Append('if (!%(value_var)s->GetAsList(&list))')
         .Append('  return %(failure_value)s;'))
       if prop.item_type.type_ == PropertyType.ENUM:
         self._GenerateListValueToEnumArrayConversion(c, prop)
       else:
         (c.Append('if (!%s)' % self._util_cc_helper.PopulateArrayFromList(
               self._cpp_type_generator.GetReferencedProperty(prop), 'list',
               dst + '->' + prop.unix_name, prop.optional))
           .Append('  return %(failure_value)s;')
         )
@@ skipping 16 matching lines @@
         .Append('  return %(failure_value)s;')
       )
       c.Eblock('}')
     elif prop.type_ == PropertyType.ENUM:
       c.Sblock('{')
       self._GenerateStringToEnumConversion(c, prop, value_var, 'enum_temp')
       c.Append('%(dst)s->%(name)s = enum_temp;')
       c.Eblock('}')
     elif prop.type_ == PropertyType.BINARY:
       # This is the same if the property is optional or not. We need a pointer
-      # to the BinaryValue to be able to populate it, so a scoped_ptr is used
-      # whether it is optional or required.
+      # to the base::BinaryValue to be able to populate it, so a scoped_ptr is
+      # used whether it is optional or required.
       (c.Append('if (!%(value_var)s->IsType(%(value_type)s))')
         .Append('  return %(failure_value)s;')
         .Append('%(dst)s->%(name)s.reset(')
-        .Append('    static_cast<BinaryValue*>(%(value_var)s)->DeepCopy());')
+        .Append('    static_cast<base::BinaryValue*>(%(value_var)s)'
+                '->DeepCopy());')
       )
     else:
       raise NotImplementedError(prop.type_)
     c.Eblock('}')
     sub = {
         'value_var': value_var,
         'name': prop.unix_name,
         'dst': dst,
         'failure_value': failure_value,
     }
@@ skipping 73 matching lines @@
 
   def _GenerateFunctionResultCreate(self, cpp_namespace, function):
     """Generate function to create a Result given the return value.
 
     E.g for function "Bar", generate Bar::Result::Create
     """
     c = Code()
     params = function.callback.params
 
     if not params:
-      (c.Append('Value* %s::Result::Create() {' % cpp_namespace)
-        .Append('  return Value::CreateNullValue();')
+      (c.Append('base::Value* %s::Result::Create() {' % cpp_namespace)
+        .Append('  return base::Value::CreateNullValue();')
         .Append('}')
       )
     else:
       expanded_params = self._cpp_type_generator.GetExpandedChoicesInParams(
           params)
       c.Concat(self._GeneratePropertyFunctions(
           cpp_namespace + '::Result', expanded_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 expanded_params:
         if param.type_ == PropertyType.ANY:
-          # Generation of Value* Create(Value*) is redundant.
+          # Generation of base::Value* Create(base::Value*) is redundant.
           continue
         # We treat this argument as 'required' to avoid wrapping it in a
         # scoped_ptr if it's optional.
         param_copy = param.Copy()
         param_copy.optional = False
-        c.Sblock('Value* %(cpp_namespace)s::Result::Create(const %(arg)s) {')
+        c.Sblock('base::Value* %(cpp_namespace)s::Result::Create('
+                 'const %(arg)s) {')
         c.Append('return %s;' %
            self._CreateValueFromProperty(param_copy, param_copy.unix_name))
         c.Eblock('}')
         c.Substitute({
             'cpp_namespace': cpp_namespace,
             'arg': cpp_util.GetParameterDeclaration(
                 param_copy, self._cpp_type_generator.GetType(param_copy))
         })
 
     return c
@@ skipping 28 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)