Docserver: Add 'deprecated since' message for API nodes

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

 # Copyright 2013 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.
 
 import posixpath
 
+from api_data_source import _NODE_CATEGORIES
 from api_schema_graph import APISchemaGraph
 from branch_utility import BranchUtility, ChannelInfo
 from compiled_file_system import CompiledFileSystem, SingleFile, Unicode
 from extensions_paths import API_PATHS, JSON_TEMPLATES
 from features_bundle import FeaturesBundle
 from file_system import FileNotFoundError
 from schema_util import ProcessSchema
 from third_party.json_schema_compiler.memoize import memoize
 from third_party.json_schema_compiler.model import UnixName
 
@@ skipping 178 matching lines @@
     '''
     if version < _SVN_MIN_VERSION:
       # SVN data isn't available below this version.
       return False
     features_bundle = self._CreateFeaturesBundle(file_system)
     available_channel = None
     if version >= _API_FEATURES_MIN_VERSION:
       # The _api_features.json file first appears in version 28 and should be
       # the most reliable for finding API availability.
       available_channel = _GetChannelFromAPIFeatures(api_name,
-                                                          features_bundle)
+                                                     features_bundle)
     if version >= _ORIGINAL_FEATURES_MIN_VERSION:
       # The _permission_features.json and _manifest_features.json files are
       # present in Chrome 20 and onwards. Use these if no information could be
       # found using _api_features.json.
       available_channel = (
           available_channel or
           _GetChannelFromPermissionFeatures(api_name, features_bundle) or
           _GetChannelFromManifestFeatures(api_name, features_bundle))
       if available_channel is not None:
         return available_channel == 'stable'
@@ skipping 142 matching lines @@
       else:
         # Keep track of any new schema elements from this version by adding
         # them to |availability_graph|.
         #
         # Calling |availability_graph|.Lookup() on the nodes being updated
         # will return the |annotation| object -- the current |channel_info|.
         version_graph = APISchemaGraph(self._GetAPISchema(api_name,
                                                           file_system,
                                                           channel_info.version))
         availability_graph.Update(version_graph.Subtract(availability_graph),
-                                  annotation=channel_info)
+                                  annotation=AvailabilityInfo(channel_info))
 
       previous.stat = version_stat
       previous.graph = version_graph
 
       # Continue looping until there are no longer differences between this
       # version and trunk.
       return version_stat != trunk_stat
 
     self._file_system_iterator.Ascending(
         self.GetAPIAvailability(api_name).channel_info,
         update_availability_graph)
 
+    # Check if any top-level nodes are scheduled.

[not at google - send to devlin, 2014/07/17 20:30:06]

wait when does this logic kick in?

[ahernandez, 2014/07/17 20:35:24]

This happens right after the graph is constructed. I wasn't sure where else I
could fit in the scheduling logic, and right after graph creation seemed
reasonable.

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

I guess i mean why do you need to add this now

[ahernandez, 2014/07/17 20:50:01]

Oh, did you want that in a separate patch? That probably makes more sense.

[not at google - send to devlin, 2014/07/17 20:57:31]

If you don't need it for this patch then yeah.

+    graph = availability_graph._graph
+    for category in _NODE_CATEGORIES:
+      if category in graph[api_name]:
+        for node in graph[api_name][category].iterkeys():
+          annotation = graph[api_name][category][node]._annotation
+          if annotation.channel_info.channel != 'stable':
+            scheduled = self._FindScheduled('%s.%s' % (api_name, node))
+            if scheduled is not None:
+              # Do not change the existing annotation object, but create
+              # a new one because multiple nodes may share the same old
+              # annotation object.
+              graph[api_name][category][node]._annotation = AvailabilityInfo(
+                  annotation.channel_info, scheduled = scheduled)
+
     self._node_level_object_store.Set(api_name, availability_graph)
     return availability_graph