Clean up 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, Type
+from model import PropertyType
 import cpp_util
-import model
 import schema_util
-import sys
 import util_cc_helper
 
 class CCGenerator(object):
   def __init__(self, type_generator, cpp_namespace):
     self._type_generator = type_generator
     self._cpp_namespace = cpp_namespace
 
   def Generate(self, namespace):
     return _Generator(namespace,
                       self._type_generator,
                       self._cpp_namespace).Generate()
 
+
 class _Generator(object):
   """A .cc generator for a namespace.
   """
   def __init__(self, namespace, cpp_type_generator, cpp_namespace):
     self._namespace = namespace
     self._type_helper = cpp_type_generator
     self._cpp_namespace = cpp_namespace
     self._target_namespace = (
         self._type_helper.GetCppNamespaceName(self._namespace))
     self._util_cc_helper = (
@@ skipping 309 matching lines @@
       # ANY is a base::Value which is abstract and cannot be a direct member, so
       # it will always be a pointer.
       is_ptr = prop.optional or prop.type_.property_type == PropertyType.ANY
       c.Append('value->SetWithoutPathExpansion("%s", %s);' % (
           prop.name,
           self._CreateValueFromType(prop.type_,
                                     'this->%s' % prop.unix_name,
                                     is_ptr=is_ptr)))
 
       if prop.optional:
-        c.Eblock('}');
+        c.Eblock('}')
 
     if type_.additional_properties is not None:
       if type_.additional_properties.property_type == PropertyType.ANY:
         c.Append('value->MergeDictionary(&additional_properties);')
       else:
         # Non-copyable types will be wrapped in a linked_ptr for inclusion in
         # maps, so we need to unwrap them.
         needs_unwrap = (
             not self._type_helper.IsCopyable(type_.additional_properties))
         cpp_type = self._type_helper.GetCppType(type_.additional_properties,
@@ skipping 12 matching lines @@
     return (c.Append()
              .Append('return value.Pass();')
            .Eblock('}'))
 
   def _GenerateChoiceTypeToValue(self, cpp_namespace, type_):
     """Generates a function that serializes a choice-representing type
     into a base::Value.
     """
     c = Code()
     c.Sblock('scoped_ptr<base::Value> %s::ToValue() const {' % cpp_namespace)
-    c.Append('scoped_ptr<base::Value> result;');
+    c.Append('scoped_ptr<base::Value> result;')
     for choice in type_.choices:
       choice_var = 'as_%s' % choice.unix_name
       (c.Sblock('if (%s) {' % choice_var)
           .Append('DCHECK(!result) << "Cannot set multiple choices for %s";' %
                       type_.unix_name)
           .Append('result.reset(%s);' %
                       self._CreateValueFromType(choice, '*%s' % choice_var))
         .Eblock('}')
       )
     (c.Append('DCHECK(result) << "Must set at least one choice for %s";' %
                   type_.unix_name)
       .Append('return result.Pass();')
       .Eblock('}')
     )
     return c
 
   def _GenerateFunction(self, function):
     """Generates the definitions for function structs.
     """
     c = Code()
 
     # TODO(kalman): use function.unix_name not Classname.
     function_namespace = cpp_util.Classname(function.name)
-    """Windows has a #define for SendMessage, so to avoid any issues, we need
-    to not use the name.
-    """
+    # Windows has a #define for SendMessage, so to avoid any issues, we need
+    # to not use the name.
     if function_namespace == 'SendMessage':
       function_namespace = 'PassMessage'
     (c.Append('namespace %s {' % function_namespace)
       .Append()
     )
 
     # Params::Populate function
     if function.params:
       c.Concat(self._GeneratePropertyFunctions('Params', function.params))
       (c.Append('Params::Params() {}')
@@ skipping 309 matching lines @@
       'key': type_.name,
       'parent_key': type_.parent.name
     })
 
   def _GenerateListValueToEnumArrayConversion(self,
                                               item_type,
                                               src_var,
                                               dst_var,
                                               failure_value,
                                               is_ptr=False):
-      """Returns Code that converts a ListValue of string constants from
-      |src_var| into an array of enums of |type_| in |dst_var|. On failure,
-      returns |failure_value|.
-      """
-      c = Code()
-      accessor = '.'
-      if is_ptr:
-        accessor = '->'
-        cpp_type = self._type_helper.GetCppType(item_type, is_in_container=True)
-        c.Append('%s.reset(new std::vector<%s>);' %
-                     (dst_var, cpp_util.PadForGenerics(cpp_type)))
-      (c.Sblock('for (base::ListValue::const_iterator it = %s->begin(); '
-                     'it != %s->end(); ++it) {' % (src_var, src_var))
-        .Append('%s tmp;' % self._type_helper.GetCppType(item_type))
-        .Concat(self._GenerateStringToEnumConversion(item_type,
-                                                     '(*it)',
-                                                     'tmp',
-                                                     failure_value))
-        .Append('%s%spush_back(tmp);' % (dst_var, accessor))
-        .Eblock('}')
-      )
-      return c
+    """Returns Code that converts a ListValue of string constants from
+    |src_var| into an array of enums of |type_| in |dst_var|. On failure,
+    returns |failure_value|.
+    """
+    c = Code()
+    accessor = '.'
+    if is_ptr:
+      accessor = '->'
+      cpp_type = self._type_helper.GetCppType(item_type, is_in_container=True)
+      c.Append('%s.reset(new std::vector<%s>);' %
+                   (dst_var, cpp_util.PadForGenerics(cpp_type)))
+    (c.Sblock('for (base::ListValue::const_iterator it = %s->begin(); '
+                   'it != %s->end(); ++it) {' % (src_var, src_var))
+      .Append('%s tmp;' % self._type_helper.GetCppType(item_type))
+      .Concat(self._GenerateStringToEnumConversion(item_type,
+                                                   '(*it)',
+                                                   'tmp',
+                                                   failure_value))
+      .Append('%s%spush_back(tmp);' % (dst_var, accessor))
+      .Eblock('}')
+    )
+    return c
 
   def _GenerateStringToEnumConversion(self,
                                       type_,
                                       src_var,
                                       dst_var,
                                       failure_value):
     """Returns Code that converts a string type in |src_var| to an enum with
     type |type_| in |dst_var|. In the generated code, if |src_var| is not
     a valid enum name then the function will return |failure_value|.
     """
@@ skipping 162 matching lines @@
     if self._generate_error_messages:
       params = list(params) + ['base::string16* error']
     return ', '.join(str(p) for p in params)
 
   def _GenerateArgs(self, args):
     """Builds the argument list for a function, given an array of arguments.
     """
     if self._generate_error_messages:
       args = list(args) + ['error']
     return ', '.join(str(a) for a in args)