Linking AvailabilityFinder with APIDataSource and intro-table templates.

chrome/common/extensions/docs/server2/patch_servlet.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 fnmatch import fnmatch
 import logging
 from urlparse import urlparse
 
 from appengine_url_fetcher import AppEngineUrlFetcher
 from appengine_wrappers import IsDevServer
 from caching_file_system import CachingFileSystem
 from caching_rietveld_patcher import CachingRietveldPatcher
 from chained_compiled_file_system import ChainedCompiledFileSystem
 from compiled_file_system import  CompiledFileSystem
+from host_file_system_creator import HostFileSystemCreator
 from instance_servlet import InstanceServlet
 from render_servlet import RenderServlet
 from rietveld_patcher import RietveldPatcher, RietveldPatcherError
 from object_store_creator import ObjectStoreCreator
 from patched_file_system import PatchedFileSystem
 from server_instance import ServerInstance
 from servlet import Request, Response, Servlet
 import svn_constants
 import url_constants
 
 class _PatchServletDelegate(RenderServlet.Delegate):
   def __init__(self, issue, delegate):
     self._issue = issue
     self._delegate = delegate
 
   def CreateServerInstanceForChannel(self, channel):
     base_object_store_creator = ObjectStoreCreator(channel,
                                                    start_empty=False)
+    branch_utility = self._delegate.CreateBranchUtility(
+        base_object_store_creator)
     # TODO(fj): Use OfflineFileSystem here once all json/idl files in api/
     # are pulled into data store by cron jobs.
     base_file_system = CachingFileSystem(
-        self._delegate.CreateHostFileSystemForBranch(channel),
+        self._delegate.CreateHostFileSystem(
+            branch_utility.GetChannelInfo(channel).branch),
         base_object_store_creator)
     base_compiled_fs_factory = CompiledFileSystem.Factory(
         base_file_system, base_object_store_creator)
 
     object_store_creator = ObjectStoreCreator('trunk@%s' % self._issue,
                                               start_empty=False)
     rietveld_patcher = CachingRietveldPatcher(
         RietveldPatcher(svn_constants.EXTENSIONS_PATH,
                         self._issue,
                         AppEngineUrlFetcher(url_constants.CODEREVIEW_SERVER)),
         object_store_creator)
     patched_file_system = PatchedFileSystem(base_file_system,
                                             rietveld_patcher)
     patched_compiled_fs_factory = CompiledFileSystem.Factory(
         patched_file_system, object_store_creator)
 
     compiled_fs_factory = ChainedCompiledFileSystem.Factory(
         [(patched_compiled_fs_factory, patched_file_system),
          (base_compiled_fs_factory, base_file_system)])
+
+    host_file_system_creator = HostFileSystemCreator(
+        branch_utility,
+        self._delegate.CreateHostFileSystem,
+        base_object_store_creator,
+        offline=False)

[not at google - send to devlin, 2013/07/09 23:11:55]

=False also not needed here

[epeterson, 2013/07/16 00:28:23]

Done.

+
     return ServerInstance(channel,
                           object_store_creator,
                           patched_file_system,
                           self._delegate.CreateAppSamplesFileSystem(
                               base_object_store_creator),
                           '/_patch/%s' % self._issue,
-                          compiled_fs_factory)
+                          compiled_fs_factory,
+                          branch_utility,
+                          host_file_system_creator)
 
 class PatchServlet(Servlet):
   '''Servlet which renders patched docs.
   '''
   def __init__(self, request, delegate=None):
     self._request = request
     self._delegate = delegate or InstanceServlet.Delegate()
 
   def Get(self):
     if (not IsDevServer() and
@@ skipping 24 matching lines @@
     except RietveldPatcherError as e:
       response = Response.NotFound(e.message, {'Content-Type': 'text/plain'})
 
     redirect_url, permanent = response.GetRedirect()
     if redirect_url is not None:
       if redirect_url.startswith('/trunk/'):
         redirect_url = redirect_url.split('/trunk', 1)[1]
       response = Response.Redirect('/_patch/%s%s' % (issue, redirect_url),
                                    permanent)
     return response