Fix up how the JSON Schema compiler decides whether to include or forward

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
 import cpp_util
 import model
 import schema_util
 import sys
@@ skipping 12 matching lines @@
 
   def Generate(self):
     """Generates a Code object with the .cc for a single namespace.
     """
     c = Code()
     (c.Append(cpp_util.CHROMIUM_LICENSE)
       .Append()
       .Append(cpp_util.GENERATED_FILE_MESSAGE % self._namespace.source_file)
       .Append()
       .Append(self._util_cc_helper.GetIncludePath())
+      .Append('#include "base/json/json_writer.h"')
+      .Append('#include "base/logging.h"')
+      .Append('#include "base/string_number_conversions.h"')
       .Append('#include "%s/%s.h"' %
           (self._namespace.source_file_dir, self._namespace.unix_name))
-      .Append('#include "base/logging.h"')
-      .Cblock(self._type_helper.GenerateIncludes())
+      .Cblock(self._type_helper.GenerateIncludes(include_soft=True))
       .Concat(self._type_helper.GetRootNamespaceStart())
       .Cblock(self._type_helper.GetNamespaceStart())
     )
     if self._namespace.properties:
       (c.Append('//')
         .Append('// Properties')
         .Append('//')
         .Append()
       )
       for property in self._namespace.properties.values():
@@ skipping 27 matching lines @@
       for event in self._namespace.events.values():
         c.Cblock(self._GenerateEvent(event))
     (c.Concat(self._type_helper.GetNamespaceEnd())
       .Cblock(self._type_helper.GetRootNamespaceEnd())
     )
     return c
 
   def _GenerateType(self, cpp_namespace, type_):
     """Generates the function definitions for a type.
     """
-    classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name))
+    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
     c = Code()
 
     if type_.functions:
       # Wrap functions within types in the type's namespace.
       (c.Append('namespace %s {' % classname)
         .Append())
       for function in type_.functions.values():
         c.Cblock(self._GenerateFunction(function))
       c.Append('}  // namespace %s' % classname)
     elif type_.property_type == PropertyType.ARRAY:
@@ skipping 62 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(schema_util.StripSchemaNamespace(type_.name))
+    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
     c = Code()
     (c.Append('// static')
       .Append('bool %(namespace)s::Populate(')
       .Sblock('    const base::Value& value, %(name)s* out) {')
     )
     if type_.property_type == PropertyType.CHOICES:
       for choice in type_.choices:
         value_type = cpp_util.GetValueType(self._type_helper.FollowRef(choice))
         (c.Sblock('if (value.IsType(%s)) {' % value_type)
             .Concat(self._GeneratePopulateVariableFromValue(
@@ skipping 525 matching lines @@
     """
     c = Code()
     for type_ in types:
       c.Cblock(self._GenerateType(namespace, type_))
     return c
 
   def _GenerateEnumToString(self, cpp_namespace, type_):
     """Generates ToString() which gets the string representation of an enum.
     """
     c = Code()
-    classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name))
+    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('std::string %sToString(%s enum_param) {' %
                  (maybe_namespace, classname))
     c.Sblock('switch (enum_param) {')
     for enum_value in self._type_helper.FollowRef(type_).enum_values:
       (c.Append('case %s: ' % self._type_helper.GetEnumValue(type_, enum_value))
         .Append('  return "%s";' % enum_value))
     (c.Append('case %s:' % self._type_helper.GetEnumNoneValue(type_))
       .Append('  return "";')
       .Eblock('}')
       .Append('NOTREACHED();')
       .Append('return "";')
       .Eblock('}')
     )
     return c
 
   def _GenerateEnumFromString(self, cpp_namespace, type_):
     """Generates FromClassNameString() which gets an enum from its string
     representation.
     """
     c = Code()
-    classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name))
+    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(
           self._type_helper.FollowRef(type_).enum_values):
       # This is broken up into all ifs with no else ifs because we get
@@ skipping 50 matching lines @@
     """
     c = Code()
     underlying_type = self._type_helper.FollowRef(prop.type_)
     if (underlying_type.property_type == PropertyType.ENUM and
         prop.optional):
       c.Append('%s->%s = %s;' % (
         dst,
         prop.unix_name,
         self._type_helper.GetEnumNoneValue(prop.type_)))
     return c