Cleanup most pylint errors in 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 cpp_util
 import schema_util
 import util_cc_helper
 from cpp_namespace_environment import CppNamespaceEnvironment
@@ skipping 42 matching lines @@
       .Append('using base::UTF8ToUTF16;')
       .Append()
       .Concat(cpp_util.OpenNamespace(cpp_namespace))
     )
     if self._namespace.properties:
       (c.Append('//')
         .Append('// Properties')
         .Append('//')
         .Append()
       )
-      for property in self._namespace.properties.values():
+      for prop in self._namespace.properties.values():
         property_code = self._type_helper.GeneratePropertyValues(
-            property,
+            prop,
             'const %(type)s %(name)s = %(value)s;',
             nodoc=True)
         if property_code:
           c.Cblock(property_code)
     if self._namespace.types:
       (c.Append('//')
         .Append('// Types')
         .Append('//')
         .Append()
         .Cblock(self._GenerateTypes(None, self._namespace.types.values()))
@@ skipping 371 matching lines @@
     if function.params:
       c.Concat(self._GeneratePropertyFunctions('Params', function.params))
       (c.Append('Params::Params() {}')
         .Append('Params::~Params() {}')
         .Append()
         .Cblock(self._GenerateFunctionParamsCreate(function))
       )
 
     # Results::Create function
     if function.callback:
-      c.Concat(self._GenerateCreateCallbackArguments(function_namespace,
-                                                     'Results',
+      c.Concat(self._GenerateCreateCallbackArguments('Results',
                                                      function.callback))
 
     c.Append('}  // namespace %s' % function_namespace)
     return c
 
   def _GenerateEvent(self, event):
     # TODO(kalman): use event.unix_name not Classname.
     c = Code()
     event_namespace = cpp_util.Classname(event.name)
     (c.Append('namespace %s {' % event_namespace)
       .Append()
-      .Cblock(self._GenerateEventNameConstant(None, event))
-      .Cblock(self._GenerateCreateCallbackArguments(event_namespace,
-                                                    None,
-                                                    event))
+      .Cblock(self._GenerateEventNameConstant(event))
+      .Cblock(self._GenerateCreateCallbackArguments(None, event))
       .Append('}  // namespace %s' % event_namespace)
     )
     return c
 
   def _CreateValueFromType(self, code, prop_name, type_, var, is_ptr=False):
     """Creates a base::Value given a type. Generated code passes ownership
     to caller.
 
     var: variable or variable*
 
@@ skipping 393 matching lines @@
     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|.
     """
     if type_.property_type != PropertyType.ENUM:
       raise TypeError(type_)
     c = Code()
     enum_as_string = '%s_as_string' % type_.unix_name
     cpp_type_namespace = ''
     if type_.namespace != self._namespace:
       cpp_type_namespace = '%s::' % type_.namespace.unix_name
-    cpp_type_name = self._type_helper.GetCppType(type_)
     (c.Append('std::string %s;' % enum_as_string)
       .Sblock('if (!%s->GetAsString(&%s)) {' % (src_var, enum_as_string))
       .Concat(self._GenerateError(
         '"\'%%(key)s\': expected string, got " + ' +
         self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
       .Append('return %s;' % failure_value)
       .Eblock('}')
       .Append('%s = %sParse%s(%s);' % (dst_var,
                                        cpp_type_namespace,
                                        cpp_util.Classname(type_.name),
@@ skipping 60 matching lines @@
     """
     c = Code()
     classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
 
     if cpp_namespace is not None:
       c.Append('// static')
     maybe_namespace = '' if cpp_namespace is None else '%s::' % cpp_namespace
 
     c.Sblock('%s%s %sParse%s(const std::string& enum_string) {' %
                  (maybe_namespace, classname, maybe_namespace, classname))
-    for i, enum_value in enumerate(
+    for _, enum_value in enumerate(
           self._type_helper.FollowRef(type_).enum_values):
       # This is broken up into all ifs with no else ifs because we get
       # "fatal error C1061: compiler limit : blocks nested too deeply"
       # on Windows.
       (c.Append('if (enum_string == "%s")' % enum_value.name)
         .Append('  return %s;' %
             self._type_helper.GetEnumValue(type_, enum_value)))
     (c.Append('return %s;' % self._type_helper.GetEnumNoneValue(type_))
       .Eblock('}')
     )
     return c
 
   def _GenerateCreateCallbackArguments(self,
-                                       cpp_namespace,
                                        function_scope,
                                        callback):
     """Generate all functions to create Value parameters for a callback.
 
     E.g for function "Bar", generate Bar::Results::Create
     E.g for event "Baz", generate Baz::Create
 
     function_scope: the function scope path, e.g. Foo::Bar for the function
                     Foo::Bar::Baz(). May be None if there is no function scope.
     callback: the Function object we are creating callback arguments for.
@@ skipping 17 matching lines @@
                                          param.unix_name))
     c.Append('return create_results.Pass();')
     c.Eblock('}')
     c.Substitute({
         'function_scope': ('%s::' % function_scope) if function_scope else '',
         'declaration_list': ', '.join(declaration_list),
         'param_names': ', '.join(param.unix_name for param in params)
     })
     return c
 
-  def _GenerateEventNameConstant(self, function_scope, event):
+  def _GenerateEventNameConstant(self, event):
     """Generates a constant string array for the event name.
     """
     c = Code()
     c.Append('const char kEventName[] = "%s.%s";' % (
                  self._namespace.name, event.name))
     return c
 
   def _InitializePropertyToDefault(self, prop, dst):
     """Initialize a model.Property to its default value inside an object.
 
@@ skipping 30 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)