Support API aliases

extensions/renderer/js_extension_bindings_system.cc

 // Copyright 2016 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/js_extension_bindings_system.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/common/content_switches.h"
 #include "extensions/common/extension.h"
+#include "extensions/common/extension_api.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/features/feature_provider.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/externally_connectable.h"
 #include "extensions/renderer/binding_generating_native_handler.h"
 #include "extensions/renderer/renderer_extension_registry.h"
 #include "extensions/renderer/resource_bundle_source_map.h"
 #include "extensions/renderer/script_context.h"
@@ skipping 149 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);
       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:
     case Feature::WEBUI_CONTEXT: {
@@ skipping 12 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 JsExtensionBindingsSystem::HandleResponse(int request_id,
                                                bool success,
                                                const base::ListValue& response,
@@ skipping 25 matching lines @@
       arguments.push_back(
           converter->ToV8Value(filtering_info, context->v8_context()));
     }
   }
 
   context->module_system()->CallModuleMethodSafe(
       kEventBindings, kEventDispatchFunction, arguments.size(),
       arguments.data());
 }
 
-void JsExtensionBindingsSystem::RegisterBinding(const std::string& api_name,
-                                                ScriptContext* context) {
+void JsExtensionBindingsSystem::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,
+    module_system->SetNativeLazyField(bind_object, bind_name, api_bind_name,
                                       "binding");
   } else {
     module_system->SetLazyField(bind_object, bind_name, api_name, "binding");
   }
 }
 
 }  // namespace extensions