Split feature definitions into extensions and chrome features.

chrome/common/extensions/docs/server2/features_bundle.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 compiled_file_system import SingleFile, Unicode
 from extensions_paths import (
-    API_FEATURES, JSON_TEMPLATES, MANIFEST_FEATURES, PERMISSION_FEATURES)
+    API_FEATURES, CHROME_API, EXTENSIONS_API, JSON_TEMPLATES, MANIFEST_FEATURES,
+    PERMISSION_FEATURES)
 import features_utility
 from file_system import FileNotFoundError
 from future import Future
 from third_party.json_schema_compiler.json_parse import Parse
 
 
+def _GetFeaturePaths(feature_file, *extra_paths):
+  paths = [posixpath.join(CHROME_API, feature_file),
+           posixpath.join(EXTENSIONS_API, feature_file)]

[Ken Rockot(use gerrit already), 2014/04/22 23:23:17]

nit: It would be nice if this could just map from API_PATHS for each
feature_file. It looks like that should be easy as _FeaturesCache should fail
silently and gracefully when APPS_API/_foo_features.json doesn't exist.

+  paths.extend(extra_paths)
+  return paths
+
+
 def _AddPlatformsFromDependencies(feature,
                                   api_features,
                                   manifest_features,
                                   permission_features):
   features_map = {
     'api': api_features,
     'manifest': manifest_features,
     'permission': permission_features,
   }
   dependencies = feature.get('dependencies')
   if dependencies is None:
     return ['apps', 'extensions']
   platforms = set()
   for dependency in dependencies:
     dep_type, dep_name = dependency.split(':')
     dependency_features = features_map[dep_type]
     dependency_feature = dependency_features.get(dep_name)
     # If the dependency can't be resolved, it is inaccessible and therefore
     # so is this feature.
     if dependency_feature is None:
       return []
     platforms = platforms.union(dependency_feature['platforms'])
   feature['platforms'] = list(platforms)
 
 
 class _FeaturesCache(object):
-  def __init__(self, file_system, compiled_fs_factory, *json_paths):
+  def __init__(self, file_system, compiled_fs_factory, json_paths):
     populate = self._CreateCache
     if len(json_paths) == 1:
       populate = SingleFile(populate)
 
     self._cache = compiled_fs_factory.Create(file_system, populate, type(self))
     self._text_cache = compiled_fs_factory.ForUnicode(file_system)
     self._json_path = json_paths[0]
     self._extra_paths = json_paths[1:]
 
   @Unicode
@@ skipping 17 matching lines @@
     return self._cache.GetFromFile(self._json_path)
 
 
 class FeaturesBundle(object):
   '''Provides access to properties of API, Manifest, and Permission features.
   '''
   def __init__(self, file_system, compiled_fs_factory, object_store_creator):
     self._api_cache = _FeaturesCache(
         file_system,
         compiled_fs_factory,
-        API_FEATURES)
+        _GetFeaturePaths(API_FEATURES))
     self._manifest_cache = _FeaturesCache(
         file_system,
         compiled_fs_factory,
-        MANIFEST_FEATURES,
-        posixpath.join(JSON_TEMPLATES, 'manifest.json'))
+        _GetFeaturePaths(MANIFEST_FEATURES,
+                         posixpath.join(JSON_TEMPLATES, 'manifest.json')))
     self._permission_cache = _FeaturesCache(
         file_system,
         compiled_fs_factory,
-        PERMISSION_FEATURES,
-        posixpath.join(JSON_TEMPLATES, 'permissions.json'))
+        _GetFeaturePaths(PERMISSION_FEATURES,
+                         posixpath.join(JSON_TEMPLATES, 'permissions.json')))
     # Namespace the object store by the file system ID because this class is
     # used by the availability finder cross-channel.
     # TODO(kalman): Configure this at the ObjectStore level.
     self._object_store = object_store_creator.Create(
         _FeaturesCache, category=file_system.GetIdentity())
 
   def GetPermissionFeatures(self):
     return self._permission_cache.GetFeatures()
 
   def GetManifestFeatures(self):
@@ skipping 14 matching lines @@
       # TODO(rockot): Handle inter-API dependencies more gracefully.
       # Not yet a problem because there is only one such case (windows -> tabs).
       # If we don't store this value before annotating platforms, inter-API
       # dependencies will lead to infinite recursion.
       for feature in api_features.itervalues():
         _AddPlatformsFromDependencies(
             feature, api_features, manifest_features, permission_features)
       self._object_store.Set('api_features', api_features)
       return api_features
     return Future(callback=resolve)