Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / chrome / common / extensions / docs / server2 / api_list_data_source.py

diff --git a/src/chrome/common/extensions/docs/server2/api_list_data_source.py b/src/chrome/common/extensions/docs/server2/api_list_data_source.py
index a4fd118..3a9c4f5 100644 (file)
--- a/src/chrome/common/extensions/docs/server2/api_list_data_source.py
+++ b/src/chrome/common/extensions/docs/server2/api_list_data_source.py
@@ -5,8 +5,9 @@
 from data_source import DataSource
 from future import Future
 from operator import itemgetter
+from platform_util import GetPlatforms
 
-from docs_server_utils import MarkLast, StringIdentity
+from docs_server_utils import MarkFirstAndLast, MarkLast
 
 class APIListDataSource(DataSource):
   """ This class creates a list of chrome.* APIs and chrome.experimental.* APIs
@@ -24,23 +25,31 @@ class APIListDataSource(DataSource):
       values are present.
   """
   def __init__(self, server_instance, _):
-    self._features_bundle = server_instance.features_bundle
-    self._api_models = server_instance.api_models
+    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=StringIdentity(self._features_bundle.GetIdentity(),
-                                self._api_models.GetIdentity()))
-    self._api_categorizer = server_instance.api_categorizer
-    self._availability_finder = server_instance.availability_finder
+        APIListDataSource, category=self._platform_bundle.GetIdentity())
 
   def _GenerateAPIDict(self):
-    def get_channel_info(api_name):
-      return self._availability_finder.GetAPIAvailability(api_name).channel_info
+    def make_list_for_content_scripts():
+      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
 
-    def get_api_platform(api_name):
-      feature = self._features_bundle.GetAPIFeatures().Get()[api_name]
-      return feature['platforms']
+      return (self._platform_bundle.GetAPIModels('extensions')
+              .GetContentScriptAPIs()
+              .Then(convert_to_list))
 
     def make_dict_for_platform(platform):
       platform_dict = {
@@ -49,17 +58,20 @@ class APIListDataSource(DataSource):
       private_apis = []
       experimental_apis = []
       all_apis = []
-      for api_name, api_model in self._api_models.IterModels():
-        if not self._api_categorizer.IsDocumented(platform, api_name):
+      for api_name, api_model in self._platform_bundle.GetAPIModels(
+          platform).IterModels():
+        if not self._platform_bundle.GetAPICategorizer(platform).IsDocumented(
+            api_name):
           continue
         api = {
           'name': api_name,
           'description': api_model.description,
-          'platforms': get_api_platform(api_name),
         }
-        category = self._api_categorizer.GetCategory(platform, api_name)
+        category = self._platform_bundle.GetAPICategorizer(
+            platform).GetCategory(api_name)
         if category == 'chrome':
-          channel_info = get_channel_info(api_name)
+          channel_info = self._platform_bundle.GetAvailabilityFinder(
+              platform).GetAPIAvailability(api_name).channel_info
           channel = channel_info.channel
           if channel == 'stable':
             version = channel_info.version
@@ -85,20 +97,24 @@ class APIListDataSource(DataSource):
         platform_dict[key] = apis
 
       return platform_dict
-    return {
-      'apps': make_dict_for_platform('apps'),
-      'extensions': make_dict_for_platform('extensions'),
-    }
+
+    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)