Docserver: Display API features that are available to content scripts

chrome/common/extensions/docs/server2/api_list_data_source.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 data_source import DataSource
 from future import Future
 from operator import itemgetter
 from platform_util import GetPlatforms
 
-from docs_server_utils import MarkLast
+from docs_server_utils import MarkFirst, MarkLast
 
 class APIListDataSource(DataSource):
   """ This class creates a list of chrome.* APIs and chrome.experimental.* APIs
   for extensions and apps that are used in the api_index.html,
   experimental.html, and private_apis.html pages.
 
   An API is considered listable if it is listed in _api_features.json,
   it has a corresponding HTML file in the public template path, and one of
   the following conditions is met:
     - It has no "dependencies" or "extension_types" properties in _api_features
     - It has an "extension_types" property in _api_features with either/both
       "extension"/"platform_app" values present.
     - It has a dependency in _{api,manifest,permission}_features with an
       "extension_types" property where either/both "extension"/"platform_app"
       values are present.
   """
   def __init__(self, server_instance, _):
     self._platform_bundle = server_instance.platform_bundle
     self._object_store = server_instance.object_store_creator.Create(
         # Update the model when the API or Features model updates.
         APIListDataSource, category=self._platform_bundle.GetIdentity())
 
   def _GenerateAPIDict(self):
+    def make_list_for_content_scripts():
+      content_script_apis = self._platform_bundle.GetAPIModels(
+          'extensions').GetContentScriptAPIs().Get()
+      content_script_apis_list = [csa.__dict__ for api_name, csa in

[not at google - send to devlin, 2014/07/21 17:51:19]

nit: everywhere else I see the "in" and "if" of list comprehensions be on the
start of the line not the end.

+                                  content_script_apis.iteritems() if
+                                  self._platform_bundle.GetAPICategorizer(
+                                      'extensions').IsDocumented(api_name)]
+
+      content_script_apis_list.sort(key=itemgetter('name'))
+      for csa in content_script_apis_list:
+        restricted_nodes = csa['restrictedTo']
+        if restricted_nodes:
+          restricted_nodes.sort(key=itemgetter('node'))
+          MarkFirst(restricted_nodes)
+          MarkLast(restricted_nodes)
+        else:
+          del csa['restrictedTo']
+      return content_script_apis_list
+
     def make_dict_for_platform(platform):
       platform_dict = {
         'chrome': {'stable': [], 'beta': [], 'dev': [], 'trunk': []},
       }
       private_apis = []
       experimental_apis = []
       all_apis = []
       for api_name, api_model in self._platform_bundle.GetAPIModels(
           platform).IterModels():
         if not self._platform_bundle.GetAPICategorizer(platform).IsDocumented(
@@ skipping 26 matching lines @@
         platform_dict['chrome'][channel] = apis_by_channel
 
       for key, apis in (('all', all_apis),
                         ('private', private_apis),
                         ('experimental', experimental_apis)):
         apis.sort(key=itemgetter('name'))
         MarkLast(apis)
         platform_dict[key] = apis
 
       return platform_dict
-    return dict((platform, make_dict_for_platform(platform))
-                for platform in GetPlatforms())
+    api_dict = dict((platform, make_dict_for_platform(platform))
+                     for platform in GetPlatforms())
+    api_dict['content_scripts'] = make_list_for_content_scripts()

[not at google - send to devlin, 2014/07/21 17:51:19]

actually can this be 'contentScripts'? Google JSON style is supposed to be
camelCase, it's just the docserver which chooses arbitrarily. let's try to stick
to camel case from now on.

+    return api_dict
 
   def _GetCachedAPIData(self):
     data_future = self._object_store.Get('api_data')
     def resolve():
       data = data_future.Get()
       if data is None:
         data = self._GenerateAPIDict()
         self._object_store.Set('api_data', data)
       return data
     return Future(callback=resolve)
 
   def get(self, key):
     return self._GetCachedAPIData().Get().get(key)
 
   def Cron(self):
     return self._GetCachedAPIData()