Support API aliases

extensions/common/extension_api.cc

 // 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.
 
 #include "extensions/common/extension_api.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 155 matching lines @@
 }
 
 void ExtensionAPI::RegisterDependencyProvider(const std::string& name,
                                               const FeatureProvider* provider) {
   dependency_providers_[name] = provider;
 }
 
 bool ExtensionAPI::IsAnyFeatureAvailableToContext(const Feature& api,
                                                   const Extension* extension,
                                                   Feature::Context context,
-                                                  const GURL& url) {
+                                                  const GURL& url,
+                                                  bool allow_alias) {
   FeatureProviderMap::iterator provider = dependency_providers_.find("api");
   CHECK(provider != dependency_providers_.end());
 
   if (api.IsAvailableToContext(extension, context, url).is_available())
     return true;
 
   // Check to see if there are any parts of this API that are allowed in this
   // context.
   const std::vector<Feature*> features = provider->second->GetChildren(api);
   for (std::vector<Feature*>::const_iterator it = features.begin();
        it != features.end();
        ++it) {
     if ((*it)->IsAvailableToContext(extension, context, url).is_available())
       return true;
   }
-  return false;
+
+  if (!allow_alias)
+    return false;
+
+  const std::string alias_name = api.GetAlias();
+  if (alias_name.empty())
+    return false;
+
+  const Feature* alias = provider->second->GetFeature(alias_name);
+  if (!alias)

[Devlin, 2016/11/14 18:03:56]

Can this happen?

[tbarzic, 2016/11/15 04:45:07]

It should not anymore

+    return false;
+  return IsAnyFeatureAvailableToContext(*alias, extension, context, url, false);
 }
 
 Feature::Availability ExtensionAPI::IsAvailable(const std::string& full_name,
                                                 const Extension* extension,
                                                 Feature::Context context,
-                                                const GURL& url) {
+                                                const GURL& url,
+                                                bool allow_alias) {
   Feature* feature = GetFeatureDependency(full_name);
   if (!feature) {
     return Feature::Availability(Feature::NOT_PRESENT,
                                  std::string("Unknown feature: ") + full_name);
   }
-  return feature->IsAvailableToContext(extension, context, url);
+
+  Feature::Availability availability =
+      feature->IsAvailableToContext(extension, context, url);
+  if (availability.is_available() || !allow_alias)
+    return availability;
+
+  Feature::Availability alias_availability =
+      IsAliasAvailable(full_name, feature, extension, context, url);
+  return alias_availability.is_available() ? alias_availability : availability;
 }
 
 base::StringPiece ExtensionAPI::GetSchemaStringPiece(
     const std::string& api_name) {
   DCHECK_EQ(api_name, GetAPINameFromFullName(api_name, nullptr));
   StringPieceMap::iterator cached = schema_strings_.find(api_name);
   if (cached != schema_strings_.end())
     return cached->second;
 
   ExtensionsClient* client = ExtensionsClient::Get();
@@ skipping 82 matching lines @@
     *child_name = "";
   return std::string();
 }
 
 bool ExtensionAPI::IsKnownAPI(const std::string& name,
                               ExtensionsClient* client) {
   return schemas_.find(name) != schemas_.end() ||
          client->IsAPISchemaGenerated(name);
 }
 
+Feature::Availability ExtensionAPI::IsAliasAvailable(
+    const std::string& full_name,
+    Feature* api,
+    const Extension* extension,
+    Feature::Context context,
+    const GURL& url) {
+  std::string alias = api->GetAlias();
+  if (alias.empty())
+    return Feature::Availability(Feature::NOT_PRESENT, "Alias not defined");
+
+  FeatureProviderMap::iterator provider = dependency_providers_.find("api");
+  CHECK(provider != dependency_providers_.end());
+
+  // Check if there is a child feature associated with full name for alias API.
+  std::string child_name;
+  GetAPINameFromFullName(full_name, &child_name);
+  std::string full_alias_name = alias + "." + child_name;
+  Feature* alias_feature = provider->second->GetFeature(full_alias_name);
+
+  // If there is no child feature, use the alias API feature to check
+  // availability.
+  if (!alias_feature)
+    alias_feature = provider->second->GetFeature(alias);
+
+  if (!alias_feature)
+    return Feature::Availability(Feature::NOT_PRESENT, "Alias not found");
+
+  return alias_feature->IsAvailableToContext(extension, context, url);
+}
+
 }  // namespace extensions