Linking AvailabilityFinder with APIDataSource and intro-table templates.

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 collections
 import os
 
 from branch_utility import BranchUtility
 from compiled_file_system import CompiledFileSystem
 from file_system import FileNotFoundError
@@ skipping 26 matching lines @@
     # The channel information dict is nested within a list for whitelisting
     # purposes.
     return feature.get('channel')
   # Features can contain a list of entries. Take the newest branch.
   return BranchUtility.NewestChannel(entry.get('channel')
                                      for entry in feature)
 
 def _GetChannelFromApiFeatures(api_name, file_system):
   try:
     return _GetChannelFromFeatures(api_name, file_system, _API_FEATURES)
-  except FileNotFoundError as e:
+  except FileNotFoundError:
     # TODO(epeterson) Remove except block once _api_features is in all channels.
     return None
 
 def _GetChannelFromPermissionFeatures(api_name, file_system):
   return _GetChannelFromFeatures(api_name, file_system, _PERMISSION_FEATURES)
 
 def _GetChannelFromManifestFeatures(api_name, file_system):
   return _GetChannelFromFeatures(#_manifest_features uses unix_style API names
                                  model.UnixName(api_name),
                                  file_system,
@@ skipping 10 matching lines @@
 def _ExistsInExtensionApi(api_name, file_system):
   '''Parses the api/extension_api.json file (available in Chrome versions
   before 18) for an API namespace. If this is successfully found, then the API
   is considered to have been 'stable' for the given version.
   '''
   try:
     extension_api_json = file_system.GetFromFile(_EXTENSION_API)
     api_rows = [row.get('namespace') for row in extension_api_json
                 if 'namespace' in row]
     return True if api_name in api_rows else False
-  except FileNotFoundError as e:
+  except FileNotFoundError:
     # This should only happen on preview.py since extension_api.json is no
     # longer present in trunk.
     return False
 
 class AvailabilityFinder(object):
   '''Uses API data sources generated by a ChromeVersionDataSource in order to
   search the filesystem for the earliest existence of a specified API throughout
   the different versions of Chrome; this constitutes an API's availability.
   '''
   class Factory(object):
@@ skipping 56 matching lines @@
     on the stable channel. When a version is found where the API is no longer
     available on stable, returns the previous version number (the last known
     version where the API was stable).
     '''
     available = True
     while available:
       if version < 5:
         # SVN data isn't available below version 5.
         return version + 1
       available = False
+      available_channel = None
       features_fs, names_fs = self._CreateFeaturesAndNamesFileSystems(version)
       if version >= 28:
         # The _api_features.json file first appears in version 28 and should be
         # the most reliable for finding API availabilities, so it gets checked
         # first. The _permission_features.json and _manifest_features.json files
         # are present in Chrome 20 and onwards. Fall back to a check for file
         # system existence if the API is not stable in any of the _features.json
         # files.
-        available = _GetChannelFromApiFeatures(api_name, features_fs) == _STABLE
+        available_channel = _GetChannelFromApiFeatures(api_name, features_fs)
       if version >= 20:
         # Check other _features.json files/file existence if the API wasn't
         # found in _api_features.json, or if _api_features.json wasn't present.
-        available = available or (
-            _GetChannelFromPermissionFeatures(api_name, features_fs) == _STABLE
-            or _GetChannelFromManifestFeatures(api_name, features_fs) == _STABLE
-            or _ExistsInFileSystem(api_name, names_fs))
+        available_channel = available_channel or (
+            _GetChannelFromPermissionFeatures(api_name, features_fs)
+            or _GetChannelFromManifestFeatures(api_name, features_fs))
+        if available_channel is None:
+          available = _ExistsInFileSystem(api_name, names_fs)
+        else:
+          available = available_channel == _STABLE
       elif version >= 18:
         # These versions are a little troublesome. Version 19 has
         # _permission_features.json, but it lacks 'channel' information.
         # Version 18 lacks all of the _features.json files. For now, we're using
         # a simple check for filesystem existence here.
         available = _ExistsInFileSystem(api_name, names_fs)
       elif version >= 5:
         # Versions 17 and down to 5 have an extension_api.json file which
         # contains namespaces for each API that was available at the time. We
         # can use this file to check for API existence.
         available = _ExistsInExtensionApi(api_name, features_fs)
 
       if not available:
         return version + 1
       version -= 1
 
   def _GetAvailableChannelForVersion(self, api_name, version):
     '''Searches through the _features files for a given |version| and returns
     the channel that the given API is determined to be available on.
     '''
     features_fs, names_fs = self._CreateFeaturesAndNamesFileSystems(version)
-    channel = (_GetChannelFromApiFeatures(api_name, features_fs)
-               or _GetChannelFromPermissionFeatures(api_name, features_fs)
-               or _GetChannelFromManifestFeatures(api_name, features_fs))
-    if channel is None and _ExistsInFileSystem(api_name, names_fs):
+    available_channel = (_GetChannelFromApiFeatures(api_name, features_fs)
+        or _GetChannelFromPermissionFeatures(api_name, features_fs)
+        or _GetChannelFromManifestFeatures(api_name, features_fs))
+    if available_channel is None and _ExistsInFileSystem(api_name, names_fs):
       # If an API is not represented in any of the _features files, but exists
       # in the filesystem, then assume it is available in this version.
       # The windows API is an example of this.
       return self._branch_utility.GetChannelForVersion(version)
 
-    return channel
+    return available_channel
 
   def GetApiAvailability(self, api_name):
     '''Determines the availability for an API by testing several scenarios.
     (i.e. Is the API experimental? Only available on certain development
     channels? If it's stable, when did it first become stable? etc.)
     '''
     availability = self._object_store.Get(api_name).Get()
     if availability is not None:
       return availability
 
     # Check for a predetermined availability for this API.
     api_info = self._json_cache.GetFromFile(_API_AVAILABILITIES).get(api_name)
     if api_info is not None:
       channel = api_info.get('channel')
-      return AvailabilityInfo(
-          channel,
-          api_info.get('version') if channel == _STABLE else None)
+      if channel == _STABLE:
+        version = api_info.get('version')
+      else:
+        version = self._branch_utility.GetChannelInfo(channel).version
+      availability = AvailabilityInfo(channel, version)
+      self._object_store.Set(api_name, availability)
+      return availability

[epeterson, 2013/07/16 00:28:23]

Previously if an API had an entry in api_availabilities.json (a predetermined
availability), then that result wasn't cached.

(although this may have been intentional?)

[not at google - send to devlin, 2013/07/16 22:25:00]

Umm yeah I remember something like this, since we were caching the
api_availabilities.json object there didn't seem much point in double-caching
it.

Let's keep it that way, but add a comment explaining it.

[epeterson, 2013/07/17 23:48:23]

Done.

 
     # Check for the API in the development channels.
     availability = None
     for channel_info in self._branch_utility.GetAllChannelInfo():
       available_channel = self._GetAvailableChannelForVersion(
           api_name,
           channel_info.version)
       # If the |available_channel| for the API is the same as, or older than,
       # the channel we're checking, then the API is available on this channel.
       if (available_channel is not None and
           BranchUtility.NewestChannel((available_channel, channel_info.channel))
               == channel_info.channel):
         availability = AvailabilityInfo(channel_info.channel,
                                         channel_info.version)
         break
 
     # The API should at least be available on trunk. It's a bug otherwise.
     assert availability, 'No availability found for %s' % api_name
 
     # If the API is in stable, find the chrome version in which it became
     # stable.
     if availability.channel == _STABLE:
       availability.version = self._FindEarliestStableAvailability(
           api_name,
           availability.version)
 
     self._object_store.Set(api_name, availability)
     return availability