Docserver: Display API features that are available to content scripts

chrome/common/extensions/docs/server2/api_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 copy import copy
 import logging
 import os
 import posixpath
 
 from data_source import DataSource
@@ skipping 248 matching lines @@
   def __repr__(self):
     return '%s > %s' % (self._namespace_name, ' > '.join(self._lookup_path))
 
 
 class _JSCModel(object):
   '''Uses a Model from the JSON Schema Compiler and generates a dict that
   a Handlebar template can use for a data source.
   '''
 
   def __init__(self,
+               api_models,
                namespace,
                availability_finder,
                json_cache,
                template_cache,
                features_bundle,
                event_byname_future):
+    self._content_script_apis = api_models.GetContentScriptAPIs().Get()

[not at google - send to devlin, 2014/07/16 00:32:20]

come to think of it, if you pass the content script APIs into here directly then
you can make use of the async fetching that |namespace| would use.

     self._availability = availability_finder.GetAPIAvailability(namespace.name)
     self._current_node = _APINodeCursor(availability_finder, namespace.name)
     self._api_availabilities = json_cache.GetFromFile(
         posixpath.join(JSON_TEMPLATES, 'api_availabilities.json'))
     self._intro_tables = json_cache.GetFromFile(
         posixpath.join(JSON_TEMPLATES, 'intro_tables.json'))
     self._api_features = features_bundle.GetAPIFeatures()
     self._template_cache = template_cache
     self._event_byname_future = event_byname_future
     self._namespace = namespace
@@ skipping 252 matching lines @@
       else:
         dst_dict['simple_type'] = type_.property_type.name
 
   def _GetIntroTableList(self):
     '''Create a generic data structure that can be traversed by the templates
     to create an API intro table.
     '''
     intro_rows = [
       self._GetIntroDescriptionRow(),
       self._GetIntroAvailabilityRow()
-    ] + self._GetIntroDependencyRows()
+    ] + self._GetIntroDependencyRows() + self._GetIntroContentScriptRow()
 
     # Add rows using data from intro_tables.json, overriding any existing rows
     # if they share the same 'title' attribute.
     row_titles = [row['title'] for row in intro_rows]
     for misc_row in self._GetMiscIntroRows():
       if misc_row['title'] in row_titles:
         intro_rows[row_titles.index(misc_row['title'])] = misc_row
       else:
         intro_rows.append(misc_row)
 
     return intro_rows
 
   def _GetAvailabilityTemplate(self, status=None, version=None, scheduled=None):
     '''Returns an object that the templates use to display availability
     information.
     '''
     if status is None:
       availability_info = self._current_node.GetAvailability()
       if availability_info is None:
         return None
       status = availability_info.channel
       version = availability_info.version
     return {
       'partial': self._template_cache.GetFromFile(
           '%sintro_tables/%s_message.html' % (PRIVATE_TEMPLATES, status)).Get(),
       'scheduled': scheduled,
       'version': version
     }
 
+  def _GetIntroContentScriptRow(self):
+    content_script_support = self._content_script_apis.get(self._namespace.name)
+    if content_script_support is None:
+      return []
+    return [{
+      'title': 'Content Scripts',
+      'content': [{
+        'partial': self._template_cache.GetFromFile(
+            posixpath.join(PRIVATE_TEMPLATES,
+                           'intro_tables',
+                           'content_scripts.html')).Get(),
+        'contentScriptSupport': content_script_support.__dict__
+      }]
+    }]
+
   def _GetIntroDescriptionRow(self):
     ''' Generates the 'Description' row data for an API intro table.
     '''
     return {
       'title': 'Description',
       'content': [
         { 'text': self._namespace.description }
       ]
     }
 
@@ skipping 139 matching lines @@
     from Event in events.json.
     '''
     if platform not in self._event_byname_futures:
       future = self._GetSchemaModel(platform, 'events')
       self._event_byname_futures[platform] = Future(
           callback=lambda: _GetEventByNameFromEvents(future.Get()))
     return self._event_byname_futures[platform]
 
   def _GetSchemaModel(self, platform, api_name):
     object_store_key = '/'.join((platform, api_name))
     jsc_model_future = self._model_cache.Get(object_store_key)

[not at google - send to devlin, 2014/07/16 00:32:20]

i.e. this async fetching.

     model_future = self._platform_bundle.GetAPIModels(platform).GetModel(
         api_name)
     def resolve():
       jsc_model = jsc_model_future.Get()
       if jsc_model is None:
         jsc_model = _JSCModel(
+            self._platform_bundle.GetAPIModels(platform),
             model_future.Get(),
             self._platform_bundle.GetAvailabilityFinder(platform),
             self._json_cache,
             self._template_cache,
             self._platform_bundle.GetFeaturesBundle(platform),
             self._LoadEventByName(platform)).ToDict()
         self._model_cache.Set(object_store_key, jsc_model)
       return jsc_model
     return Future(callback=resolve)
 
@@ skipping 17 matching lines @@
     getter = lambda: 0
     getter.get = lambda api_name: self._GetImpl(platform, api_name).Get()
     return getter
 
   def Cron(self):
     futures = []
     for platform in GetPlatforms():
       futures += [self._GetImpl(platform, name)
           for name in self._platform_bundle.GetAPIModels(platform).GetNames()]
     return Collect(futures, except_pass=FileNotFoundError)