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

   1 # Copyright 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import posixpath
   6
   7 from compiled_file_system import SingleFile, Unicode
   8 from extensions_paths import API_PATHS, JSON_TEMPLATES
   9 import features_utility
  10 from file_system import FileNotFoundError
  11 from future import Future
  12 from third_party.json_schema_compiler.json_parse import Parse
  13
  14
  15 _API_FEATURES = '_api_features.json'
  16 _MANIFEST_FEATURES = '_manifest_features.json'
  17 _PERMISSION_FEATURES = '_permission_features.json'
  18
  19
  20 def _GetFeaturePaths(feature_file, *extra_paths):
  21   paths = [posixpath.join(api_path, feature_file) for api_path in API_PATHS]
  22   paths.extend(extra_paths)
  23   return paths
  24
  25
  26 def _AddPlatformsFromDependencies(feature,
  27                                   api_features,
  28                                   manifest_features,
  29                                   permission_features):
  30   features_map = {
  31     'api': api_features,
  32     'manifest': manifest_features,
  33     'permission': permission_features,
  34   }
  35   dependencies = feature.get('dependencies')
  36   if dependencies is None:
  37     return ['apps', 'extensions']
  38   platforms = set()
  39   for dependency in dependencies:
  40     dep_type, dep_name = dependency.split(':')
  41     dependency_features = features_map[dep_type]
  42     dependency_feature = dependency_features.get(dep_name)
  43     # If the dependency can't be resolved, it is inaccessible and therefore
  44     # so is this feature.
  45     if dependency_feature is None:
  46       return []
  47     platforms = platforms.union(dependency_feature['platforms'])
  48   feature['platforms'] = list(platforms)
  49
  50
  51 class _FeaturesCache(object):
  52   def __init__(self, file_system, compiled_fs_factory, json_paths):
  53     populate = self._CreateCache
  54     if len(json_paths) == 1:
  55       populate = SingleFile(populate)
  56
  57     self._cache = compiled_fs_factory.Create(file_system, populate, type(self))
  58     self._text_cache = compiled_fs_factory.ForUnicode(file_system)
  59     self._json_path = json_paths[0]
  60     self._extra_paths = json_paths[1:]
  61
  62   @Unicode
  63   def _CreateCache(self, _, features_json):
  64     extra_path_futures = [self._text_cache.GetFromFile(path)
  65                           for path in self._extra_paths]
  66     features = features_utility.Parse(Parse(features_json))
  67     for path_future in extra_path_futures:
  68       try:
  69         extra_json = path_future.Get()
  70       except FileNotFoundError:
  71         # Not all file system configurations have the extra files.
  72         continue
  73       features = features_utility.MergedWith(
  74           features_utility.Parse(Parse(extra_json)), features)
  75     return features
  76
  77   def GetFeatures(self):
  78     if self._json_path is None:
  79       return Future(value={})
  80     return self._cache.GetFromFile(self._json_path)
  81
  82
  83 class FeaturesBundle(object):
  84   '''Provides access to properties of API, Manifest, and Permission features.
  85   '''
  86   def __init__(self, file_system, compiled_fs_factory, object_store_creator):
  87     self._api_cache = _FeaturesCache(
  88         file_system,
  89         compiled_fs_factory,
  90         _GetFeaturePaths(_API_FEATURES))
  91     self._manifest_cache = _FeaturesCache(
  92         file_system,
  93         compiled_fs_factory,
  94         _GetFeaturePaths(_MANIFEST_FEATURES,
  95                          posixpath.join(JSON_TEMPLATES, 'manifest.json')))
  96     self._permission_cache = _FeaturesCache(
  97         file_system,
  98         compiled_fs_factory,
  99         _GetFeaturePaths(_PERMISSION_FEATURES,
 100                          posixpath.join(JSON_TEMPLATES, 'permissions.json')))
 101     # Namespace the object store by the file system ID because this class is
 102     # used by the availability finder cross-channel.
 103     # TODO(kalman): Configure this at the ObjectStore level.
 104     self._object_store = object_store_creator.Create(
 105         _FeaturesCache, category=file_system.GetIdentity())
 106
 107   def GetPermissionFeatures(self):
 108     return self._permission_cache.GetFeatures()
 109
 110   def GetManifestFeatures(self):
 111     return self._manifest_cache.GetFeatures()
 112
 113   def GetAPIFeatures(self):
 114     api_features = self._object_store.Get('api_features').Get()
 115     if api_features is not None:
 116       return Future(value=api_features)
 117
 118     api_features_future = self._api_cache.GetFeatures()
 119     manifest_features_future = self._manifest_cache.GetFeatures()
 120     permission_features_future = self._permission_cache.GetFeatures()
 121     def resolve():
 122       api_features = api_features_future.Get()
 123       manifest_features = manifest_features_future.Get()
 124       permission_features = permission_features_future.Get()
 125       # TODO(rockot): Handle inter-API dependencies more gracefully.
 126       # Not yet a problem because there is only one such case (windows -> tabs).
 127       # If we don't store this value before annotating platforms, inter-API
 128       # dependencies will lead to infinite recursion.
 129       for feature in api_features.itervalues():
 130         _AddPlatformsFromDependencies(
 131             feature, api_features, manifest_features, permission_features)
 132       self._object_store.Set('api_features', api_features)
 133       return api_features
 134     return Future(callback=resolve)