Refactor the devserver to make it easier to control caching

chrome/common/extensions/docs/server2/reference_resolver.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.
 
 from file_system import FileNotFoundError
+from object_store_creator import ObjectStoreCreator
 import logging
-import object_store
 import re
 import string
 
 def _ClassifySchemaNode(node_name, api):
   """Attempt to classify |node_name| in an API, determining whether |node_name|
   refers to a type, function, event, or property in |api|.
   """
   if '.' in node_name:
     node_name, rest = node_name.split('.', 1)
   else:
@@ skipping 25 matching lines @@
                     title is set to the name of the node.
 
     $ref:[api.node The Title] - Same as the previous form but title is set to
                                 "The Title".
   """
 
   # Matches after a $ref: that doesn't have []s.
   _bare_ref = re.compile('\w+(\.\w+)*')
 
   class Factory(object):
-    def __init__(self,
-                 api_data_source_factory,
-                 api_list_data_source_factory,
-                 object_store):
+    def __init__(self, api_data_source_factory, api_list_data_source_factory):
       self._api_data_source_factory = api_data_source_factory
       self._api_list_data_source_factory = api_list_data_source_factory
-      self._object_store = object_store
 
     def Create(self):
       return ReferenceResolver(
           self._api_data_source_factory.Create(None, disable_refs=True),
           self._api_list_data_source_factory.Create(),
-          self._object_store)
+          ObjectStoreCreator(ReferenceResolver).Create())
 
   def __init__(self, api_data_source, api_list_data_source, object_store):
     self._api_data_source = api_data_source
     self._api_list_data_source = api_list_data_source
     self._object_store = object_store
 
   def _GetRefLink(self, ref, api_list, namespace, title):
     # Check nodes within each API the ref might refer to.
     parts = ref.split('.')
     for i, part in enumerate(parts):
@@ skipping 42 matching lines @@
         'text': title if title else ref,
         'name': ref
       }
 
     return None
 
   def GetLink(self, ref, namespace=None, title=None):
     """Resolve $ref |ref| in namespace |namespace| if not None, returning None
     if it cannot be resolved.
     """
-    link = self._object_store.Get(_MakeKey(namespace, ref, title),
-                                  object_store.REFERENCE_RESOLVER).Get()
+    link = self._object_store.Get(_MakeKey(namespace, ref, title)).Get()
     if link is not None:
       return link
 
     api_list = self._api_list_data_source.GetAllNames()
     link = self._GetRefLink(ref, api_list, namespace, title)
 
     if link is None and namespace is not None:
       # Try to resolve the ref in the current namespace if there is one.
       link = self._GetRefLink('%s.%s' % (namespace, ref),
                               api_list,
                               namespace,
                               title)
 
     if link is not None:
-      self._object_store.Set(_MakeKey(namespace, ref, title),
-                             link,
-                             object_store.REFERENCE_RESOLVER)
+      self._object_store.Set(_MakeKey(namespace, ref, title), link)
     return link
 
   def SafeGetLink(self, ref, namespace=None, title=None):
     """Resolve $ref |ref| in namespace |namespace|, or globally if None. If it
     cannot be resolved, pretend like it is a link to a type.
     """
     ref_data = self.GetLink(ref, namespace=namespace, title=title)
     if ref_data is not None:
       return ref_data
     logging.error('$ref %s could not be resolved in namespace %s.' %
@@ skipping 35 matching lines @@
           ref = ''
           rest = ref_and_rest
         else:
           ref = match.group()
           rest = ref_and_rest[match.end():]
 
       ref_dict = self.SafeGetLink(ref, namespace=namespace, title=title)
       formatted_text.append('<a href="%(href)s">%(text)s</a>%(rest)s' %
           { 'href': ref_dict['href'], 'text': ref_dict['text'], 'rest': rest })
     return ''.join(formatted_text)