[Schema Compiler] Separate out SchemaLoader and namespace resolving

tools/json_schema_compiler/compiler.py

 #!/usr/bin/env python
 # 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.
 """Generator for C++ structs from api json files.
 
 The purpose of this tool is to remove the need for hand-written code that
 converts to and from base::Value types when receiving javascript api calls.
 Originally written for generating code for extension apis. Reference schemas
 are in chrome/common/extensions/api.
@@ skipping 11 matching lines @@
 import sys
 
 from cpp_bundle_generator import CppBundleGenerator
 from cpp_generator import CppGenerator
 from cpp_type_generator import CppTypeGenerator
 from js_externs_generator import JsExternsGenerator
 from js_interface_generator import JsInterfaceGenerator
 import json_schema
 from cpp_namespace_environment import CppNamespaceEnvironment
 from model import Model
+from namespace_resolver import NamespaceResolver
 from schema_loader import SchemaLoader
 
 # Names of supported code generators, as specified on the command-line.
 # First is default.
 GENERATORS = [
   'cpp', 'cpp-bundle-registration', 'cpp-bundle-schema', 'externs', 'interface'
 ]
 
 def GenerateSchema(generator_name,
                    file_paths,
                    root,
                    destdir,
                    cpp_namespace_pattern,
                    bundle_name,
                    impl_dir,
                    include_rules):
   # Merge the source files into a single list of schemas.
   api_defs = []
   for file_path in file_paths:
     schema = os.path.relpath(file_path, root)
-    schema_loader = SchemaLoader(
-        root,
-        os.path.dirname(schema),
-        include_rules,
-        cpp_namespace_pattern)
-    api_def = schema_loader.LoadSchema(schema)
+    api_def = SchemaLoader(root).LoadSchema(schema)
 
     # If compiling the C++ model code, delete 'nocompile' nodes.
     if generator_name == 'cpp':
       api_def = json_schema.DeleteNodes(api_def, 'nocompile')
 
     # Delete all 'nodefine' nodes. They are only for documentation.
     api_def = json_schema.DeleteNodes(api_def, 'nodefine')
 
     api_defs.extend(api_def)
 
@@ skipping 21 matching lines @@
 
     if src_path is None:
       src_path = namespace.source_file_dir
     else:
       src_path = os.path.commonprefix((src_path, namespace.source_file_dir))
 
     _, filename = os.path.split(file_path)
     filename_base, _ = os.path.splitext(filename)
 
   # Construct the type generator with all the namespaces in this model.
+  schema_dir = os.path.dirname(os.path.relpath(file_paths[0], root))
+  namespace_resolver = NamespaceResolver(root, schema_dir,
+                                         include_rules, cpp_namespace_pattern)
   type_generator = CppTypeGenerator(api_model,
-                                    schema_loader,
+                                    namespace_resolver,
                                     default_namespace)
   if generator_name in ('cpp-bundle-registration', 'cpp-bundle-schema'):
     cpp_bundle_generator = CppBundleGenerator(root,
                                               api_model,
                                               api_defs,
                                               type_generator,
                                               cpp_namespace_pattern,
                                               bundle_name,
                                               src_path,
                                               impl_dir)
@@ skipping 95 matching lines @@
   include_rules = []
   if opts.include_rules:
     include_rules = map(split_path_and_namespace,
                         shlex.split(opts.include_rules))
 
   result = GenerateSchema(opts.generator, file_paths, opts.root, opts.destdir,
                           opts.namespace, opts.bundle_name, opts.impl_dir,
                           include_rules)
   if not opts.destdir:
     print result