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

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, Type
 import cpp_util
 import schema_util
 
 class HGenerator(object):
@@ skipping 22 matching lines @@
       .Append()
       .Append('#include <map>')
       .Append('#include <string>')
       .Append('#include <vector>')
       .Append()
       .Append('#include "base/basictypes.h"')
       .Append('#include "base/logging.h"')
       .Append('#include "base/memory/linked_ptr.h"')
       .Append('#include "base/memory/scoped_ptr.h"')
       .Append('#include "base/values.h"')
+      .Cblock(self._type_helper.GenerateIncludes())
       .Append()
     )
 
     c.Concat(self._type_helper.GetRootNamespaceStart())
     # TODO(calamity): These forward declarations should be #includes to allow
     # $ref types from other files to be used as required params. This requires
     # some detangling of windows and tabs which will currently lead to circular
     # #includes.
     forward_declarations = (
         self._type_helper.GenerateForwardDeclarations())
@@ skipping 102 matching lines @@
   def _GenerateType(self, type_, is_toplevel=False, generate_typedefs=False):
     """Generates a struct for |type_|.
 
     |is_toplevel|       implies that the type was declared in the "types" field
                         of an API schema. This determines the correct function
                         modifier(s).
     |generate_typedefs| controls whether primitive types should be generated as
                         a typedef. This may not always be desired. If false,
                         primitive types are ignored.
     """
-    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)
@@ skipping 182 matching lines @@
   def _GenerateFunctionResults(self, callback):
     """Generates namespace for passing a function's result back.
     """
     c = Code()
     (c.Append('namespace Results {')
       .Append()
       .Concat(self._GenerateCreateCallbackArguments(callback))
       .Append('}  // namespace Results')
     )
     return c