Docserver: Modify doc inlining so all relevant data is present in availability_finder.py

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_schema_graph import APISchemaGraph
 from branch_utility import BranchUtility, ChannelInfo
+from compiled_file_system import CompiledFileSystem, SingleFile, Unicode
 from extensions_paths import API_PATHS, JSON_TEMPLATES
 from features_bundle import FeaturesBundle
 from file_system import FileNotFoundError
+from schema_util import ProcessSchema
 from third_party.json_schema_compiler.memoize import memoize
 from third_party.json_schema_compiler.model import UnixName
 
 
 _DEVTOOLS_API = 'devtools_api.json'
 _EXTENSION_API = 'extension_api.json'
 # The version where api_features.json is first available.
 _API_FEATURES_MIN_VERSION = 28
 # The version where permission_ and manifest_features.json are available and
 # presented in the current format.
@@ skipping 113 matching lines @@
     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 comp_func(path, data):

[not at google - send to devlin, 2014/07/16 20:03:49]

s/comp_func/process_schema/

+      return ProcessSchema(path, data, retain_inlined_types=True)
+    return self._compiled_fs_factory.Create(file_system,
+                                            SingleFile(Unicode(comp_func)),
+                                            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)
     if api_filename is None:
       # No file for the API could be found in the given |file_system|.
       return None
 
-    schema_fs = self._compiled_fs_factory.ForAPISchema(file_system)
+    schema_fs = self._CreateAPISchemaFileSystem(file_system)
     api_schemas = schema_fs.GetFromFile(api_filename).Get()
     matching_schemas = [api for api in api_schemas
                         if api['namespace'] == api_name]
     # There should only be a single matching schema per file, or zero in the
     # case of no API data being found in _EXTENSION_API.
     assert len(matching_schemas) <= 1
     return matching_schemas or None
 
   def _HasAPISchema(self, api_name, file_system, version):
     '''Whether or not an API schema for |api_name| exists in the given
@@ skipping 191 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