Docserver: Add annotation to intro_tables.json to restrict content by platform

chrome/common/extensions/docs/server2/jsc_view.py

 # Copyright 2014 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 posixpath
 
 from api_models import GetNodeCategories
 from api_schema_graph import APINodeCursor
 from docs_server_utils import MarkFirstAndLast
 from extensions_paths import JSON_TEMPLATES, PRIVATE_TEMPLATES
 from operator import itemgetter
+from platform_util import PlatformToExtensionType
 import third_party.json_schema_compiler.model as model
 
 
 def GetEventByNameFromEvents(events):
   '''Parses the dictionary |events| to find the definitions of members of the
   type Event.  Returns a dictionary mapping the name of a member to that
   member's definition.
   '''
   assert 'types' in events, \
       'The dictionary |events| must contain the key "types".'
@@ skipping 28 matching lines @@
   return '-'.join([prefix, node.simple_name])
 
 
 def _FormatValue(value):
   '''Inserts commas every three digits for integer values. It is magic.
   '''
   s = str(value)
   return ','.join([s[max(0, i - 3):i] for i in range(len(s), 0, -3)][::-1])
 
 
-
-
 class JSCView(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,
                jsc_model,
                availability_finder,
                json_cache,
                template_cache,
                features_bundle,
-               event_byname_future):
+               event_byname_future,
+               platform):
     self._content_script_apis = content_script_apis
     self._availability = availability_finder.GetAPIAvailability(jsc_model.name)
     self._current_node = APINodeCursor(availability_finder, jsc_model.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._jsc_model = jsc_model
+    self._platform = platform
 
   def _GetLink(self, link):
     ref = link if '.' in link else (self._jsc_model.name + '.' + link)
     return { 'ref': ref, 'text': link, 'name': link }
 
   def ToDict(self):
     '''Returns a dictionary representation of |self._jsc_model|, which
     is a Namespace object from JSON Schema Compiler.
     '''
     assert self._jsc_model is not None
@@ skipping 439 matching lines @@
     # Look up the API name in intro_tables.json, which is structured
     # similarly to the data structure being created. If the name is found, loop
     # through the attributes and add them to this structure.
     table_info = self._intro_tables.Get().get(self._jsc_model.name)
     if table_info is None:
       return misc_rows
 
     for category in table_info.iterkeys():
       content = []
       for node in table_info[category]:
+        ext_type = PlatformToExtensionType(self._platform)
+        # Don't display nodes restricted to a different platform.
+        if ext_type not in node.get('extension_types', [ext_type]):

[not at google - send to devlin, 2014/08/01 19:59:53]

nit: use (ext_type,) not [ext_type]

+          continue
         # If there is a 'partial' argument and it hasn't already been
         # converted to a Handlebar object, transform it to a template.
         if 'partial' in node:
           # Note: it's enough to copy() not deepcopy() because only a single
           # top-level key is being modified.
           node = copy(node)
           node['partial'] = self._template_cache.GetFromFile(
               posixpath.join(PRIVATE_TEMPLATES, node['partial'])).Get()
         content.append(node)
       misc_rows.append({ 'title': category, 'content': content })
     return misc_rows