Inlining references to internal APIs.

chrome/common/extensions/docs/server2/availability_finder.py

 # Copyright 2013 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.
 
 import posixpath
 
 from api_models import GetNodeCategories
 from api_schema_graph import APISchemaGraph
 from branch_utility import BranchUtility, ChannelInfo
 from compiled_file_system import CompiledFileSystem, SingleFile, Unicode
@@ skipping 99 matching lines @@
   '''Generates availability information for APIs by looking at API schemas and
   _features files over multiple release versions of Chrome.
   '''
 
   def __init__(self,
                branch_utility,
                compiled_fs_factory,
                file_system_iterator,
                host_file_system,
                object_store_creator,
-               platform):
+               platform,
+               process_schema_factory):
     self._branch_utility = branch_utility
     self._compiled_fs_factory = compiled_fs_factory
     self._file_system_iterator = file_system_iterator
     self._host_file_system = host_file_system
     self._object_store_creator = object_store_creator
     def create_object_store(category):
       return object_store_creator.Create(
           AvailabilityFinder, category='/'.join((platform, category)))
     self._top_level_object_store = create_object_store('top_level')
     self._node_level_object_store = create_object_store('node_level')
     self._json_fs = compiled_fs_factory.ForJson(self._host_file_system)
     self._platform = platform
+    # When processing the API schemas, we retain inlined types in the schema
+    # so that there are not missing nodes in the APISchemaGraphs when trying
+    # to lookup availability.
+    self._process_schema = process_schema_factory.Create(True)
 
   def _GetPredeterminedAvailability(self, api_name):
     '''Checks a configuration file for hardcoded (i.e. predetermined)
     availability information for an API.
     '''
     api_info = self._json_fs.GetFromFile(
         JSON_TEMPLATES + 'api_availabilities.json').Get().get(api_name)
     if api_info is None:
       return None
     if api_info['channel'] == 'stable':
       return AvailabilityInfo(
           self._branch_utility.GetStableChannelInfo(api_info['version']))
     return AvailabilityInfo(
         self._branch_utility.GetChannelInfo(api_info['channel']))
 
   @memoize
   def _CreateAPISchemaFileSystem(self, file_system):
     '''Creates a CompiledFileSystem for parsing raw JSON or IDL API schema
     data and formatting it so that it can be used to create APISchemaGraphs.
     '''
-    # When processing the API schemas, we retain inlined types in the schema
-    # so that there are not missing nodes in the APISchemaGraphs when trying
-    # to lookup availability.
     def process_schema(path, data):
-      return ProcessSchema(path, data, retain_inlined_types=True)
+      return self._process_schema.Process(path, data)
     return self._compiled_fs_factory.Create(file_system,
                                             SingleFile(Unicode(process_schema)),
                                             CompiledFileSystem,
                                             category='api-schema')
 
   def _GetAPISchema(self, api_name, file_system, version):
     '''Searches |file_system| for |api_name|'s API schema data, and processes
     and returns it if found.
     '''
     api_filename = _GetAPISchemaFilename(api_name, file_system, version)
@@ skipping 278 matching lines @@
       # Continue looping until there are no longer differences between this
       # version and trunk.
       return version_stat != trunk_stat
 
     self._file_system_iterator.Ascending(
         self.GetAPIAvailability(api_name).channel_info,
         update_availability_graph)
 
     self._node_level_object_store.Set(api_name, availability_graph)
     return availability_graph