Docserver: Consolidate features caching and access.

chrome/common/extensions/docs/server2/manifest_data_source.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 json
 
 from data_source import DataSource
 import features_utility
-from manifest_features import CreateManifestFeatures, ConvertDottedKeysToNested
+from manifest_features import ConvertDottedKeysToNested
 from third_party.json_schema_compiler.json_parse import Parse
 
 def _ListifyAndSortDocs(features, app_name):
   '''Convert a |feautres| dictionary, and all 'children' dictionaries, into
   lists recursively. Sort lists first by 'level' then by name.
   '''
   def sort_key(item):
     '''Key function to sort items primarily by level (according to index into
     levels) then subsort by name.
     '''
@@ skipping 73 matching lines @@
     if features:
       features[-1]['is_last'] = True
 
   annotate('required', features)
   return features
 
 class ManifestDataSource(DataSource):
   '''Provides access to the properties in manifest features.
   '''
   def __init__(self, server_instance, _):
-    self._manifest_path = server_instance.manifest_json_path
-    self._features_path = server_instance.manifest_features_path
-    self._file_system = server_instance.host_file_system
-    self._cache = server_instance.compiled_host_fs_factory.Create(
-        self._CreateManifestData, ManifestDataSource)
+    self._features_bundle = server_instance.features_bundle
+    self._cache = None
 
-  def _CreateManifestData(self, _, content):
-    '''Combine the contents of |_manifest_path| and |_features_path| and filter
-    the results into lists specific to apps or extensions for templates. Marks
-    up features with annotations.
-    '''
+  def _CreateCache(self):
     def for_templates(manifest_features, platform):
       return _AddLevelAnnotations(
           _ListifyAndSortDocs(
               ConvertDottedKeysToNested(
                   features_utility.Filtered(manifest_features, platform)),
               app_name=platform.capitalize()))
-
-    manifest_json = Parse(self._file_system.ReadSingle(self._manifest_path))
-    manifest_features = CreateManifestFeatures(
-        features_json=Parse(content), manifest_json=manifest_json)
-
+    manifest_features = self._features_bundle.GetManifestFeatures()
     return {
-      'apps': for_templates(manifest_features, 'app'),
-      'extensions': for_templates(manifest_features, 'extension')
+      'apps': for_templates(manifest_features, 'apps'),
+      'extensions': for_templates(manifest_features, 'extensions')
     }
 
   def Cron(self):
-    self._cache.GetFromFile(self._features_path)
-    self._file_system.ReadSingle(self._manifest_path)
+    self._cache = self._CreateCache()
 
   def get(self, key):
-    return self._cache.GetFromFile(self._features_path)[key]
+    if self._cache is None:
+      self._cache = self._CreateCache()
+    return self._cache.get(key)

[not at google - send to devlin, 2013/10/01 16:34:34]

you could also consider doing this with an ObjectStore,and maybe separate out
the apps and extensions into separate keys if you want to have more fine-grained
caching; though, not necessary. simple enough as it is. though that said the old
way of using a CompiledFileSystem seems simpler.

[Ken Rockot(use gerrit already), 2013/10/01 22:18:16]

Done, minus fine-grained caching.