Conver APIListDataSource to use Future.Then() rather than Get().

chrome/common/extensions/docs/server2/api_list_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 data_source import DataSource
 from future import Future
 from operator import itemgetter
 from platform_util import GetPlatforms
 
 from docs_server_utils import MarkFirstAndLast, MarkLast
@@ skipping 14 matching lines @@
       values are present.
   """
   def __init__(self, server_instance, _):
     self._platform_bundle = server_instance.platform_bundle
     self._object_store = server_instance.object_store_creator.Create(
         # Update the model when the API or Features model updates.
         APIListDataSource, category=self._platform_bundle.GetIdentity())
 
   def _GenerateAPIDict(self):
     def make_list_for_content_scripts():
-      content_script_apis = self._platform_bundle.GetAPIModels(
-          'extensions').GetContentScriptAPIs().Get()
-      content_script_apis_list = [csa.__dict__ for api_name, csa
-                                  in content_script_apis.iteritems()
-                                  if self._platform_bundle.GetAPICategorizer(
-                                      'extensions').IsDocumented(api_name)]
+      def convert_to_list(content_script_apis):
+        content_script_apis_list = [csa.__dict__ for api_name, csa
+                                    in content_script_apis.iteritems()
+                                    if self._platform_bundle.GetAPICategorizer(
+                                        'extensions').IsDocumented(api_name)]
+        content_script_apis_list.sort(key=itemgetter('name'))
+        for csa in content_script_apis_list:
+          restricted_nodes = csa['restrictedTo']
+          if restricted_nodes:
+            restricted_nodes.sort(key=itemgetter('node'))
+            MarkFirstAndLast(restricted_nodes)
+          else:
+            del csa['restrictedTo']
+        return content_script_apis_list
 
-      content_script_apis_list.sort(key=itemgetter('name'))
-      for csa in content_script_apis_list:
-        restricted_nodes = csa['restrictedTo']
-        if restricted_nodes:
-          restricted_nodes.sort(key=itemgetter('node'))
-          MarkFirstAndLast(restricted_nodes)
-        else:
-          del csa['restrictedTo']
-      return content_script_apis_list
+      return (self._platform_bundle.GetAPIModels('extensions')
+              .GetContentScriptAPIs()
+              .Then(convert_to_list))
 
     def make_dict_for_platform(platform):
       platform_dict = {
         'chrome': {'stable': [], 'beta': [], 'dev': [], 'trunk': []},
       }
       private_apis = []
       experimental_apis = []
       all_apis = []
       for api_name, api_model in self._platform_bundle.GetAPIModels(
           platform).IterModels():

[not at google - send to devlin, 2014/08/05 18:47:18]

IterModels() might be a problem, it's an implicit Get() operation, albeit an
optimised one which tries to run in parallel. Something to note.

         if not self._platform_bundle.GetAPICategorizer(platform).IsDocumented(
             api_name):
           continue
         api = {
           'name': api_name,
           'description': api_model.description,
         }
         category = self._platform_bundle.GetAPICategorizer(
             platform).GetCategory(api_name)
         if category == 'chrome':
@@ skipping 17 matching lines @@
         platform_dict['chrome'][channel] = apis_by_channel
 
       for key, apis in (('all', all_apis),
                         ('private', private_apis),
                         ('experimental', experimental_apis)):
         apis.sort(key=itemgetter('name'))
         MarkLast(apis)
         platform_dict[key] = apis
 
       return platform_dict
-    api_dict = dict((platform, make_dict_for_platform(platform))
-                     for platform in GetPlatforms())
-    api_dict['contentScripts'] = make_list_for_content_scripts()
-    return api_dict
+
+    def make_api_dict(content_script_apis):
+      api_dict = dict((platform, make_dict_for_platform(platform))
+                       for platform in GetPlatforms())
+      api_dict['contentScripts'] = content_script_apis
+      return api_dict
+
+    return make_list_for_content_scripts().Then(make_api_dict)
 
   def _GetCachedAPIData(self):
-    data_future = self._object_store.Get('api_data')
-    def resolve():
-      data = data_future.Get()
+    def persist_and_return(data):
+      self._object_store.Set('api_data', data)
+      return data
+    def return_or_generate(data):
       if data is None:
-        data = self._GenerateAPIDict()
-        self._object_store.Set('api_data', data)
+        return self._GenerateAPIDict().Then(persist_and_return)
       return data
-    return Future(callback=resolve)
+    return self._object_store.Get('api_data').Then(return_or_generate)
 
   def get(self, key):
     return self._GetCachedAPIData().Get().get(key)
 
   def Cron(self):
     return self._GetCachedAPIData()