Support API aliases

extensions/renderer/dispatcher.cc

 // Copyright 2014 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/renderer/dispatcher.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 1342 matching lines @@
   // TODO(kalman): Make the bindings registration have zero overhead then run
   // the same code regardless of context type.
   switch (context->context_type()) {
     case Feature::UNSPECIFIED_CONTEXT:
     case Feature::WEB_PAGE_CONTEXT:
     case Feature::BLESSED_WEB_PAGE_CONTEXT:
       // Hard-code registration of any APIs that are exposed to webpage-like
       // contexts, because it's too expensive to run the full bindings code.
       // All of the same permission checks will still apply.
       if (context->GetAvailability("app").is_available())
-        RegisterBinding("app", context);
+        RegisterBinding("app", "app", context);
       if (context->GetAvailability("webstore").is_available())
-        RegisterBinding("webstore", context);
+        RegisterBinding("webstore", "webstore", context);
       if (context->GetAvailability("dashboardPrivate").is_available())
-        RegisterBinding("dashboardPrivate", context);
+        RegisterBinding("dashboardPrivate", "dashboardPrivate", context);
       if (IsRuntimeAvailableToContext(context))
-        RegisterBinding("runtime", context);
+        RegisterBinding("runtime", "runtime", context);
       UpdateContentCapabilities(context);
       break;
 
     case Feature::SERVICE_WORKER_CONTEXT:
       DCHECK(ExtensionsClient::Get()
                  ->ExtensionAPIEnabledInExtensionServiceWorkers());
     // Intentional fallthrough.
     case Feature::BLESSED_EXTENSION_CONTEXT:
     case Feature::UNBLESSED_EXTENSION_CONTEXT:
     case Feature::CONTENT_SCRIPT_CONTEXT:
@@ skipping 13 matching lines @@
         if (api_feature_provider->GetParent(map_entry.second.get()) != nullptr)
           continue;
 
         // Skip chrome.test if this isn't a test.
         if (map_entry.first == "test" &&
             !base::CommandLine::ForCurrentProcess()->HasSwitch(
                 ::switches::kTestType)) {
           continue;
         }
 
-        if (context->IsAnyFeatureAvailableToContext(*map_entry.second)) {
+        if (context->IsAnyFeatureAvailableToContext(
+                *map_entry.second, CheckAliasStatus::NOT_ALLOWED)) {
+          // Check if the API feature is indeed an alias. If it is, the API
+          // should use source API bindings as its own.
+          const std::string& source = map_entry.second->source();
           // TODO(lazyboy): RegisterBinding() uses |source_map_|, any thread
           // safety issue?
-          RegisterBinding(map_entry.first, context);
+          RegisterBinding(source.empty() ? map_entry.first : source,
+                          map_entry.first, context);
         }
       }
       break;
     }
   }
 }
 
 void Dispatcher::RegisterBinding(const std::string& api_name,
+                                 const std::string& api_bind_name,
                                  ScriptContext* context) {
   std::string bind_name;
   v8::Local<v8::Object> bind_object =
-      GetOrCreateBindObjectIfAvailable(api_name, &bind_name, context);
+      GetOrCreateBindObjectIfAvailable(api_bind_name, &bind_name, context);
 
   // Empty if the bind object failed to be created, probably because the
   // extension overrode chrome with a non-object, e.g. window.chrome = true.
   if (bind_object.IsEmpty())
     return;
 
   v8::Local<v8::String> v8_bind_name =
       v8::String::NewFromUtf8(context->isolate(), bind_name.c_str());
   if (bind_object->HasRealNamedProperty(v8_bind_name)) {
     // The bind object may already have the property if the API has been
     // registered before (or if the extension has put something there already,
     // but, whatevs).
     //
     // In the former case, we need to re-register the bindings for the APIs
     // which the extension now has permissions for (if any), but not touch any
     // others so that we don't destroy state such as event listeners.
     //
     // TODO(kalman): Only register available APIs to make this all moot.
     if (bind_object->HasRealNamedCallbackProperty(v8_bind_name))
       return;  // lazy binding still there, nothing to do
     if (bind_object->Get(v8_bind_name)->IsObject())
       return;  // binding has already been fully installed
   }
 
   ModuleSystem* module_system = context->module_system();
   if (!source_map_.Contains(api_name)) {
     module_system->RegisterNativeHandler(
-        api_name,
+        api_bind_name,
         std::unique_ptr<NativeHandler>(
             new BindingGeneratingNativeHandler(context, api_name, "binding")));
-    module_system->SetNativeLazyField(
-        bind_object, bind_name, api_name, "binding");
+    module_system->SetNativeLazyField(bind_object, bind_name, api_bind_name,
+                                      "binding");
   } else {
     module_system->SetLazyField(bind_object, bind_name, api_name, "binding");
   }
 }
 
 // NOTE: please use the naming convention "foo_natives" for these.
 void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
                                         ScriptContext* context,
                                         RequestSender* request_sender,
                                         V8SchemaRegistry* v8_schema_registry) {
@@ skipping 115 matching lines @@
   //  If app.window is available and app is not, delete app and install
   //  app.window on a new object so app does not have to be loaded.
   const FeatureProvider* api_feature_provider =
       FeatureProvider::GetAPIFeatures();
   std::string ancestor_name;
   bool only_ancestor_available = false;
 
   for (size_t i = 0; i < split.size() - 1; ++i) {
     ancestor_name += (i ? "." : "") + split[i];
     if (api_feature_provider->GetFeature(ancestor_name) &&
-        context->GetAvailability(ancestor_name).is_available() &&
-        !context->GetAvailability(api_name).is_available()) {
+        context->GetAvailability(ancestor_name, CheckAliasStatus::NOT_ALLOWED)
+            .is_available() &&
+        !context->GetAvailability(api_name, CheckAliasStatus::NOT_ALLOWED)
+             .is_available()) {
       only_ancestor_available = true;
       break;
     }
 
     if (bind_object.IsEmpty()) {
       bind_object = AsObjectOrEmpty(GetOrCreateChrome(context));
       if (bind_object.IsEmpty())
         return v8::Local<v8::Object>();
     }
     bind_object = GetOrCreateObject(bind_object, split[i], context->isolate());
@@ skipping 52 matching lines @@
   // The "guestViewDeny" module must always be loaded last. It registers
   // error-providing custom elements for the GuestView types that are not
   // available, and thus all of those types must have been checked and loaded
   // (or not loaded) beforehand.
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT) {
     module_system->Require("guestViewDeny");
   }
 }
 
 }  // namespace extensions