Dynamically generate a heading for Extension Docs API pages

chrome/common/extensions/docs/server2/server_instance.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 fnmatch import fnmatch
 import logging
 import mimetypes
 import traceback
 import os
 
 from api_data_source import APIDataSource
 from api_list_data_source import APIListDataSource
 from appengine_blobstore import AppEngineBlobstore
 from appengine_url_fetcher import AppEngineUrlFetcher
 from appengine_wrappers import GetAppVersion, IsDevServer
+from availability_data_source import AvailabilityDataSource
 from branch_utility import BranchUtility
 from caching_file_system import CachingFileSystem
+from chrome_version_utility import ChromeVersionUtility
 from compiled_file_system import CompiledFileSystem
 from empty_dir_file_system import EmptyDirFileSystem
 from example_zipper import ExampleZipper
 from file_system import FileNotFoundError
 from github_file_system import GithubFileSystem
 from intro_data_source import IntroDataSource
 from local_file_system import LocalFileSystem
 from object_store_creator import ObjectStoreCreator
 from offline_file_system import OfflineFileSystem
 from path_canonicalizer import PathCanonicalizer
@@ skipping 21 matching lines @@
   github_file_system = None
 
   @staticmethod
   @memoize
   def GetOrCreateOffline(channel):
     '''Gets/creates a local ServerInstance, meaning that only resources local to
     the server - memcache, object store, etc, are queried. This amounts to not
     setting up the subversion nor github file systems.
     '''
     branch_utility = ServerInstance._GetOrCreateBranchUtility()
-    branch = branch_utility.GetBranchNumberForChannelName(channel)
+    branch = branch_utility.GetChannelInfoForChannelName(channel).branch
     object_store_creator_factory = ObjectStoreCreator.Factory(GetAppVersion(),
                                                               branch)
     # No svn nor github file systems. Rely on the crons to fill the caches, and
     # for the caches to exist.
     return ServerInstance(
         channel,
         object_store_creator_factory,
         CachingFileSystem(OfflineFileSystem(SubversionFileSystem),
                           object_store_creator_factory),
         # TODO(kalman): convert GithubFileSystem to be wrappable in a
         # CachingFileSystem so that it can be replaced with an
         # OfflineFileSystem. Currently GFS doesn't set the child versions of
         # stat requests so it doesn't.
         ServerInstance._GetOrCreateGithubFileSystem())
 
   @staticmethod
   def CreateOnline(channel):
     '''Creates/creates an online server instance, meaning that both local and
     subversion/github resources are queried.
     '''
     branch_utility = ServerInstance._GetOrCreateBranchUtility()
-    branch = branch_utility.GetBranchNumberForChannelName(channel)
+    branch = branch_utility.GetChannelInfoForChannelName(channel).branch
 
     if branch == 'trunk':
       svn_url = '/'.join((url_constants.SVN_TRUNK_URL,
                           'src',
                           svn_constants.EXTENSIONS_PATH))
     else:
       svn_url = '/'.join((url_constants.SVN_BRANCH_URL,
                           branch,
                           'src',
                           svn_constants.EXTENSIONS_PATH))
@@ skipping 49 matching lines @@
                svn_file_system,
                github_file_system):
     self.svn_file_system = svn_file_system
 
     self.github_file_system = github_file_system
 
     self.compiled_fs_factory = CompiledFileSystem.Factory(
         svn_file_system,
         object_store_creator_factory)
 
+    self.chrome_version_utility = ChromeVersionUtility(
+        url_constants.OMAHA_DEV_HISTORY,
+        AppEngineUrlFetcher(None),
+        object_store_creator_factory)
+
+    self.availability_data_source_factory = AvailabilityDataSource.Factory(
+        self.chrome_version_utility,
+        object_store_creator_factory,
+        svn_file_system)

[not at google - send to devlin, 2013/04/30 18:34:19]

I think we need to pass in a special trunk svn file system here?

[epeterson, 2013/05/13 02:38:10]

Definitely, thanks for catching that.

+
     self.api_list_data_source_factory = APIListDataSource.Factory(
         self.compiled_fs_factory,
         svn_constants.API_PATH,
         svn_constants.PUBLIC_TEMPLATE_PATH)
 
     self.api_data_source_factory = APIDataSource.Factory(
         self.compiled_fs_factory,
-        svn_constants.API_PATH)
+        svn_constants.API_PATH,
+        self.availability_data_source_factory,
+        svn_file_system)
 
     self.ref_resolver_factory = ReferenceResolver.Factory(
         self.api_data_source_factory,
         self.api_list_data_source_factory,
         object_store_creator_factory)
 
     self.api_data_source_factory.SetReferenceResolverFactory(
         self.ref_resolver_factory)
 
     # Note: samples are super slow in the dev server because it doesn't support
@@ skipping 79 matching lines @@
 
     response.headers['x-frame-options'] = 'sameorigin'
     if content is None:
       response.set_status(404);
       response.out.write(templates.Render('404'))
     else:
       if not content:
         logging.error('%s had empty content' % path)
       response.headers['cache-control'] = 'max-age=300'
       response.out.write(content)