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
-from docs_server_utils import StringIdentity
+from docs_server_utils import StringIdentity, MarkFirstAndLast
 from environment import IsPreviewServer, IsReleaseServer
 from extensions_paths import JSON_TEMPLATES, PRIVATE_TEMPLATES
 from file_system import FileNotFoundError
 from future import Future, Collect
+from operator import itemgetter
 from platform_util import GetPlatforms
 import third_party.json_schema_compiler.json_parse as json_parse
 import third_party.json_schema_compiler.model as model
 from third_party.json_schema_compiler.memoize import memoize
 
 
 # The set of possible categories a node may belong to.
 _NODE_CATEGORIES = ('types', 'functions', 'events', 'properties')
 
 
@@ skipping 245 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,
+               content_script_apis,
                namespace,
                availability_finder,
                json_cache,
                template_cache,
                features_bundle,
                event_byname_future):
+    self._content_script_apis = content_script_apis
     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 _CreateAvailabilityTemplate(self, status, scheduled, version):
     '''Returns an object suitable for use in templates to display availability
     information.
     '''
     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 []
+    if content_script_support.restrictedTo:
+      content_script_support.restrictedTo.sort(key=itemgetter('node'))
+      MarkFirstAndLast(content_script_support.restrictedTo)
+    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 _GetAvailabilityTemplate(self):
     '''Gets availability for the current node and returns an appropriate
     template object.
     '''
     # Displaying deprecated status takes precedence over when the API
     # became stable.
     availability_info = self._current_node.GetDeprecated()
     if availability_info is not None:
       status = 'deprecated'
     else:
@@ skipping 156 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))
+    api_models = self._platform_bundle.GetAPIModels(platform)
     jsc_model_future = self._model_cache.Get(object_store_key)
-    model_future = self._platform_bundle.GetAPIModels(platform).GetModel(
-        api_name)
+    model_future = api_models.GetModel(api_name)
+    content_script_apis_future = api_models.GetContentScriptAPIs()
     def resolve():
       jsc_model = jsc_model_future.Get()
       if jsc_model is None:
         jsc_model = _JSCModel(
+            content_script_apis_future.Get(),
             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)