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

chrome/common/extensions/docs/server2/object_store_creator.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 cache_chain_object_store import CacheChainObjectStore
 from memcache_object_store import MemcacheObjectStore
 from persistent_object_store import PersistentObjectStore
 
 class ObjectStoreCreator(object):
   class Factory(object):
     '''Parameters:
     - |branch| The branch to create object stores for. This becomes part of the
       namespace for the object stores that are created.
     - |start_empty| Whether the caching object store that gets created should
       start empty, or start with the content of its delegate object stores.
+    - |persistent| Whether the caching object store is persistent.
+    - |more| A dictionary containing other information to include in the
+      namespace.
     '''
-    def __init__(self, app_version, branch, start_empty=False):
+    def __init__(self,
+                 app_version,
+                 branch,
+                 start_empty=False,
+                 persistent=True,

[not at google - send to devlin, 2013/04/30 15:37:42]

I was wondering, it actually seems fine to just persist this. At some point I'll
write code to clear out stale object store entries, and besides we have a lot of
object store quota, so that's fine. It means this stuff will end up being
faster.

[方觉(Fang Jue), 2013/05/01 15:27:25]

Since you say it's fine, then I'll use persistent object store by default. And
in the end this file doesn't need changing at all!

+                 more=None):
       self._app_version = app_version
       self._branch = branch
       self._start_empty = start_empty
+      self._persistent = persistent
+      self._more = more
 
     def Create(self, cls, store_type=None):
       return ObjectStoreCreator(cls,
                                 self._app_version,
                                 self._branch,
                                 store_type=store_type,
-                                start_empty=self._start_empty)
+                                start_empty=self._start_empty,
+                                persistent=self._persistent,
+                                more=self._more)
 
   class SharedFactory(object):
     '''A |Factory| for creating object stores shared across branches.
     '''
     def __init__(self, app_version):
       self._factory = ObjectStoreCreator.Factory(app_version, 'shared')
 
     def Create(self, cls, store_type=None):
       return self._factory.Create(cls, store_type=store_type)
 
   class TestFactory(object):
     '''A |Factory| for creating object stores for tests, with fake defaults.
     '''
     def __init__(self):
       self._factory = ObjectStoreCreator.Factory('test-version', 'test-branch')
 
     def Create(self, cls, store_type=None):
       return self._factory.Create(cls, store_type=store_type)
 
   def __init__(self,
                cls,
                app_version,
                branch,
                store_type=None,
-               start_empty=False):
+               start_empty=False,
+               persistent=True,
+               more=None):
     '''Creates stores with a top-level namespace given by the name of |cls|
     combined with |branch|. Set an explicit |store_type| if necessary for tests.
 
     By convention this should be the name of the class which owns the object
     store. If a class needs multiple object stores it should use Create with the
     |category| argument.
     '''
     assert isinstance(cls, type)
     assert not cls.__name__[0].islower()  # guard against non-class types
-    self._name = '%s/%s@%s' % (app_version, cls.__name__, branch)
+    _components = {
+      'version': app_version,
+      'branch': branch,
+      'cls': cls.__name__,
+    }
+    if more:
+      _components.update(more)
+    self._name = '/'.join('%s=%s' % (key, _components[key])
+        for key in sorted(_components.keys()))
     self._store_type = store_type
     self._start_empty = start_empty
+    self._persistent = persistent
 
   def Create(self, category=None):
     '''Creates a new object store with the top namespace given in the
     constructor with an optional |category| for classes that need multiple
     object stores (e.g. one for stat and one for read).
     '''
     namespace = self._name
     if category is not None:
       assert not any(c.isdigit() for c in category)

[not at google - send to devlin, 2013/04/30 15:37:42]

to answer your question - the reason why category can't have number is so that
it doesn't get confused with version. However, you're changing the way this
works anyway, so you can remove this restriction.

       namespace = '%s/%s' % (namespace, category)
     if self._store_type is not None:
       return self._store_type(namespace)
-    return CacheChainObjectStore(
-        (MemcacheObjectStore(namespace), PersistentObjectStore(namespace)),
-        start_empty=self._start_empty)
+    object_stores = (MemcacheObjectStore(namespace),)
+    if self._persistent:
+      object_stores += (PersistentObjectStore(namespace),)

[not at google - send to devlin, 2013/04/30 15:37:42]

fwiw, if you're modifying lists, use a list not a tuple.

+    return CacheChainObjectStore(object_stores, start_empty=self._start_empty)