Docserver: Add support for viewing docs with a codereview patch applied

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

 # Copyright (c) 2012 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.
 
 class _CacheEntry(object):
   def __init__(self, cache_data, version):
-    self._cache_data = cache_data
+    self.cache_data = cache_data
     self.version = version
 
 class CompiledFileSystem(object):
   """This class caches FileSystem data that has been processed.
   """
   class Factory(object):
     """A class to build a CompiledFileSystem backed by |file_system|.
     """
     def __init__(self, file_system, object_store_creator):

[not at google - send to devlin, 2013/05/11 20:39:53]

See comments in CacheChainFileSystem. I don't think this file really needs to
change. 

[方觉(Fang Jue), 2013/05/12 03:01:47]

No. Factory doesn't need to be changed. But there must be some way to expose
CacheEntry so that ChainedCompiledFileSystem knows the version of the data read.

       self._file_system = file_system
       self._object_store_creator = object_store_creator
 
     def Create(self, populate_function, cls, category=None):
       """Create a CompiledFileSystem that populates the cache by calling
       |populate_function| with (path, data), where |data| is the data that was
       fetched from |path|.
       The namespace for the file system is derived like ObjectStoreCreator: from
       |cls| along with an optional |category|.
       """
+      return self._Create(populate_function, cls, category)
+
+    def _Create(self,
+                populate_function,
+                cls,
+                category=None,
+                constructor=None):
       assert isinstance(cls, type)
       assert not cls.__name__[0].islower()  # guard against non-class types
       full_name = cls.__name__
       if category is not None:
         full_name = '%s/%s' % (full_name, category)
       def create_object_store(category):
         return self._object_store_creator.Create(
             CompiledFileSystem, category='%s/%s' % (full_name, category))
-      return CompiledFileSystem(self._file_system,
-                                populate_function,
-                                create_object_store('file'),
-                                create_object_store('list'))
+      if constructor is None:
+        constructor = CompiledFileSystem
+      return constructor(self._file_system,
+                         populate_function,
+                         create_object_store('file'),
+                         create_object_store('list'))
 
     def CreateIdentity(self, cls):
       '''Handy helper to get or create the identity compiled file system.
       GetFromFile will return the file's contents.
       GetFromFileListing will return the directory list.
       '''
       return self.Create(lambda _, x: x, cls)
 
   def __init__(self,
                file_system,
@@ skipping 14 matching lines @@
       else:
         files.append(filename)
     return files
 
   def GetFromFile(self, path, binary=False):
     """Calls |populate_function| on the contents of the file at |path|.  If
     |binary| is True then the file will be read as binary - but this will only
     apply for the first time the file is fetched; if already cached, |binary|
     will be ignored.
     """
+    return self._GetCacheEntryFromFile(path, binary).cache_data
+
+  def _GetCacheEntryFromFile(self, path, binary=False):
     version = self._file_system.Stat(path).version
     cache_entry = self._file_object_store.Get(path).Get()
     if (cache_entry is not None) and (version == cache_entry.version):
-      return cache_entry._cache_data
+      return cache_entry
     cache_data = self._populate_function(
         path,
         self._file_system.ReadSingle(path, binary=binary))
-    self._file_object_store.Set(path, _CacheEntry(cache_data, version))
-    return cache_data
+    cache_entry = _CacheEntry(cache_data, version)
+    self._file_object_store.Set(path, cache_entry)
+    return cache_entry
 
   def GetFromFileListing(self, path):
     """Calls |populate_function| on the listing of the files at |path|.
     Assumes that the path given is to a directory.
     """
     if not path.endswith('/'):
       path += '/'
+    return self._GetCacheEntryFromFileListing(path).cache_data
+
+  def _GetCacheEntryFromFileListing(self, path):
+    assert path.endswith('/')
     version = self._file_system.Stat(path).version
     cache_entry = self._list_object_store.Get(path).Get()
     if (cache_entry is not None) and (version == cache_entry.version):
-        return cache_entry._cache_data
+        return cache_entry
     cache_data = self._populate_function(path, self._RecursiveList(path))
-    self._list_object_store.Set(path, _CacheEntry(cache_data, version))
-    return cache_data
+    cache_entry = _CacheEntry(cache_data, version)
+    self._list_object_store.Set(path, cache_entry)
+    return cache_entry