Doc server: support interfaces in src/extensions

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.
 
 from collections import Mapping
 import posixpath
 
 from api_schema_graph import APISchemaGraph
 from branch_utility import BranchUtility
-from extensions_paths import API, JSON_TEMPLATES
+from extensions_paths import (
+    API, CHROME_API, JSON_TEMPLATES, API_FEATURES, MANIFEST_FEATURES,
+    PERMISSION_FEATURES)
 from third_party.json_schema_compiler.model import UnixName
 
 
 _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.
 _ORIGINAL_FEATURES_MIN_VERSION = 20
 # API schemas are aggregated in extension_api.json up to this version.
 _EXTENSION_API_MAX_VERSION = 17
 # The earliest version for which we have SVN data.
 _SVN_MIN_VERSION = 5
 
 
 def _GetChannelFromFeatures(api_name, json_fs, filename):
   '''Finds API channel information from the features |filename| within the the
   given |json_fs|. Returns None if channel information for the API cannot be
   located.
   '''
-  feature = json_fs.GetFromFile(API + filename).Get().get(api_name)
+  feature = json_fs.GetFromFile(filename).Get().get(api_name)
   if feature is None:
     return None
   if isinstance(feature, Mapping):
     # The channel information exists as a solitary dict.
     return feature.get('channel')
   # The channel information dict is nested within a list for whitelisting
   # purposes. Take the newest channel out of all of the entries.
   return BranchUtility.NewestChannel(entry.get('channel') for entry in feature)
 
 
 def _GetChannelFromApiFeatures(api_name, json_fs):
-  return _GetChannelFromFeatures(api_name, json_fs, '_api_features.json')
+  return _GetChannelFromFeatures(api_name, json_fs, API_FEATURES)
 
 
 def _GetChannelFromManifestFeatures(api_name, json_fs):
   # _manifest_features.json uses unix_style API names.
   api_name = UnixName(api_name)
-  return _GetChannelFromFeatures(api_name, json_fs, '_manifest_features.json')
+  return _GetChannelFromFeatures(api_name, json_fs, MANIFEST_FEATURES)
 
 
 def _GetChannelFromPermissionFeatures(api_name, json_fs):
-  return _GetChannelFromFeatures(api_name, json_fs, '_permission_features.json')
+  return _GetChannelFromFeatures(api_name, json_fs, PERMISSION_FEATURES)
 
 
 class AvailabilityFinder(object):
   '''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,
@@ skipping 23 matching lines @@
       return self._branch_utility.GetStableChannelInfo(api_info['version'])
     else:
       return self._branch_utility.GetChannelInfo(api_info['channel'])
 
   def _GetApiSchemaFilename(self, api_name, file_system, version):
     '''Gets the name of the file which may contain the schema for |api_name| in
     |file_system|, or None if the API is not found. Note that this may be the
     single _EXTENSION_API file which all APIs share in older versions of Chrome,
     in which case it is unknown whether the API actually exists there.
     '''
-    def under_api_path(path):
-      return API + path
+    def find_schema_under_path(api_name, path):
+      # |file_system| will cache the results from the ReadSingle() call.
+      if not file_system.Exists(path).Get():
+        return None
+      filenames = file_system.ReadSingle(path).Get()
+      for ext in ('json', 'idl'):
+        filename = '%s.%s' % (api_name, ext)
+        if filename in filenames:
+          return path + filename
+      if _EXTENSION_API in filenames:
+        return path + _EXTENSION_API
+      # API schema data could not be found in any .json or .idl file.
+      return None
 
     if version == 'trunk' or version > _ORIGINAL_FEATURES_MIN_VERSION:
       # API schema filenames switch format to unix_hacker_style.
       api_name = UnixName(api_name)
 
-    # |file_system| will cache the results from the ReadSingle() call.
-    filenames = file_system.ReadSingle(API).Get()
-
-    for ext in ('json', 'idl'):
-      filename = '%s.%s' % (api_name, ext)
-      if filename in filenames:
-        return under_api_path(filename)
-    if _EXTENSION_API in filenames:
-      return under_api_path(_EXTENSION_API)
-    # API schema data could not be found in any .json or .idl file.
-    return None
+    filename = find_schema_under_path(api_name, API)
+    if filename is not None:
+      return filename
+    return find_schema_under_path(api_name, CHROME_API)
 
   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 = self._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
 
@@ skipping 154 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),
                                          update_availability_graph)
 
     self._node_level_object_store.Set(api_name, availability_graph)
     return availability_graph