[Extensions Bindings] Add ExtensionBindingsSystem interface; hook it up

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/feature_list.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/string_piece.h"
-#include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "content/grit/content_resources.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "extensions/common/api/messaging/message.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/features/behavior_feature.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/features/feature_channel.h"
 #include "extensions/common/features/feature_provider.h"
 #include "extensions/common/features/feature_util.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/content_capabilities_handler.h"
-#include "extensions/common/manifest_handlers/externally_connectable.h"
 #include "extensions/common/manifest_handlers/options_page_info.h"
 #include "extensions/common/message_bundle.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/switches.h"
 #include "extensions/common/view_type.h"
 #include "extensions/renderer/api_activity_logger.h"
 #include "extensions/renderer/api_definitions_natives.h"
 #include "extensions/renderer/app_window_custom_bindings.h"
-#include "extensions/renderer/binding_generating_native_handler.h"
 #include "extensions/renderer/blob_native_handler.h"
 #include "extensions/renderer/content_watcher.h"
 #include "extensions/renderer/context_menus_custom_bindings.h"
 #include "extensions/renderer/dispatcher_delegate.h"
 #include "extensions/renderer/display_source_custom_bindings.h"
 #include "extensions/renderer/document_custom_bindings.h"
 #include "extensions/renderer/dom_activity_logger.h"
 #include "extensions/renderer/event_bindings.h"
 #include "extensions/renderer/extension_frame_helper.h"
 #include "extensions/renderer/extension_helper.h"
 #include "extensions/renderer/extensions_renderer_client.h"
 #include "extensions/renderer/file_system_natives.h"
 #include "extensions/renderer/guest_view/guest_view_internal_custom_bindings.h"
 #include "extensions/renderer/id_generator_custom_bindings.h"
+#include "extensions/renderer/js_extension_bindings_system.h"
 #include "extensions/renderer/logging_native_handler.h"
 #include "extensions/renderer/messaging_bindings.h"
 #include "extensions/renderer/module_system.h"
 #include "extensions/renderer/process_info_native_handler.h"
 #include "extensions/renderer/render_frame_observer_natives.h"
 #include "extensions/renderer/renderer_extension_registry.h"
 #include "extensions/renderer/request_sender.h"
 #include "extensions/renderer/runtime_custom_bindings.h"
 #include "extensions/renderer/safe_builtins.h"
 #include "extensions/renderer/script_context.h"
@@ skipping 41 matching lines @@
 using blink::WebVector;
 using blink::WebView;
 using content::RenderThread;
 
 namespace extensions {
 
 namespace {
 
 static const int64_t kInitialExtensionIdleHandlerDelayMs = 5 * 1000;
 static const int64_t kMaxExtensionIdleHandlerDelayMs = 5 * 60 * 1000;
-static const char kEventDispatchFunction[] = "dispatchEvent";
 static const char kOnSuspendEvent[] = "runtime.onSuspend";
 static const char kOnSuspendCanceledEvent[] = "runtime.onSuspendCanceled";
 
 void CrashOnException(const v8::TryCatch& trycatch) {
   NOTREACHED();
 };
 
-// Returns the global value for "chrome" from |context|. If one doesn't exist
-// creates a new object for it.
-//
-// Note that this isn't necessarily an object, since webpages can write, for
-// example, "window.chrome = true".
-v8::Local<v8::Value> GetOrCreateChrome(ScriptContext* context) {
-  v8::Local<v8::String> chrome_string(
-      v8::String::NewFromUtf8(context->isolate(), "chrome"));
-  v8::Local<v8::Object> global(context->v8_context()->Global());
-  v8::Local<v8::Value> chrome(global->Get(chrome_string));
-  if (chrome->IsUndefined()) {
-    chrome = v8::Object::New(context->isolate());
-    global->Set(chrome_string, chrome);
-  }
-  return chrome;
-}
-
-// Returns |value| cast to an object if possible, else an empty handle.
-v8::Local<v8::Object> AsObjectOrEmpty(v8::Local<v8::Value> value) {
-  return value->IsObject() ? value.As<v8::Object>() : v8::Local<v8::Object>();
-}
-
 // Calls a method |method_name| in a module |module_name| belonging to the
 // module system from |context|. Intended as a callback target from
 // ScriptContextSet::ForEach.
 void CallModuleMethod(const std::string& module_name,
                       const std::string& method_name,
                       const base::ListValue* args,
                       ScriptContext* context) {
   v8::HandleScope handle_scope(context->isolate());
   v8::Context::Scope context_scope(context->v8_context());
 
@@ skipping 13 matching lines @@
 class ChromeNativeHandler : public ObjectBackedNativeHandler {
  public:
   explicit ChromeNativeHandler(ScriptContext* context)
       : ObjectBackedNativeHandler(context) {
     RouteFunction(
         "GetChrome",
         base::Bind(&ChromeNativeHandler::GetChrome, base::Unretained(this)));
   }
 
   void GetChrome(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    args.GetReturnValue().Set(GetOrCreateChrome(context()));
+    // Check for the chrome property. If one doesn't exist, create one.
+    v8::Local<v8::String> chrome_string(
+        v8::String::NewFromUtf8(context()->isolate(), "chrome"));
+    v8::Local<v8::Object> global(context()->v8_context()->Global());
+    v8::Local<v8::Value> chrome(global->Get(chrome_string));
+    if (chrome->IsUndefined()) {
+      chrome = v8::Object::New(context()->isolate());
+      global->Set(chrome_string, chrome);
+    }
+    args.GetReturnValue().Set(chrome);
   }
 };
 
 base::LazyInstance<WorkerScriptContextSet> g_worker_script_context_set =
     LAZY_INSTANCE_INITIALIZER;
 
-// Dispatches the event with the given name, arguments, and filtering info in
-// the given |context|.
-void DispatchEventInContext(const std::string& event_name,
-                            const base::ListValue* event_args,
-                            const base::DictionaryValue* filtering_info,
-                            ScriptContext* context) {
-  v8::HandleScope handle_scope(context->isolate());
-  v8::Context::Scope context_scope(context->v8_context());
-
-  std::vector<v8::Local<v8::Value>> arguments;
-  arguments.push_back(gin::StringToSymbol(context->isolate(), event_name));
-
-  {
-    std::unique_ptr<content::V8ValueConverter> converter(
-        content::V8ValueConverter::create());
-    arguments.push_back(
-        converter->ToV8Value(event_args, context->v8_context()));
-    if (!filtering_info->empty()) {
-      arguments.push_back(
-          converter->ToV8Value(filtering_info, context->v8_context()));
-    }
-  }
-
-  context->module_system()->CallModuleMethodSafe(
-      kEventBindings, kEventDispatchFunction, arguments.size(),
-      arguments.data());
-}
-
 }  // namespace
 
 // Note that we can't use Blink public APIs in the constructor becase Blink
 // is not initialized at the point we create Dispatcher.
 Dispatcher::Dispatcher(DispatcherDelegate* delegate)
     : delegate_(delegate),
       content_watcher_(new ContentWatcher()),
       source_map_(&ResourceBundle::GetSharedInstance()),
       v8_schema_registry_(new V8SchemaRegistry),
+      bindings_system_(
+          new JsExtensionBindingsSystem(&source_map_,
+                                        base::MakeUnique<RequestSender>())),
       user_script_set_manager_observer_(this),
       activity_logging_enabled_(false) {
   const base::CommandLine& command_line =
       *(base::CommandLine::ForCurrentProcess());
   set_idle_notifications_ =
       command_line.HasSwitch(switches::kExtensionProcess) ||
       command_line.HasSwitch(::switches::kSingleProcess);
 
   if (set_idle_notifications_) {
     RenderThread::Get()->SetIdleNotificationDelayInMs(
         kInitialExtensionIdleHandlerDelayMs);
   }
 
   script_context_set_.reset(new ScriptContextSet(&active_extension_ids_));
   user_script_set_manager_.reset(new UserScriptSetManager());
   script_injection_manager_.reset(
       new ScriptInjectionManager(user_script_set_manager_.get()));
   user_script_set_manager_observer_.Add(user_script_set_manager_.get());
-  request_sender_.reset(new RequestSender());
   PopulateSourceMap();
   WakeEventPage::Get()->Init(RenderThread::Get());
   // Ideally this should be done after checking
   // ExtensionAPIEnabledInExtensionServiceWorkers(), but the Dispatcher is
   // created so early that sending an IPC from browser/ process to synchronize
   // this enabled-ness is too late.
   WorkerThreadDispatcher::Get()->Init(RenderThread::Get());
 
   RenderThread::Get()->RegisterExtension(SafeBuiltins::CreateV8Extension());
 
@@ skipping 85 matching lines @@
   {
     std::unique_ptr<ModuleSystem> module_system(
         new ModuleSystem(context, &source_map_));
     context->set_module_system(std::move(module_system));
   }
   ModuleSystem* module_system = context->module_system();
 
   // Enable natives in startup.
   ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system);
 
-  RegisterNativeHandlers(module_system, context, request_sender_.get(),
+  RegisterNativeHandlers(module_system, context,
+                         bindings_system_->GetRequestSender(),
                          v8_schema_registry_.get());
 
-  // chrome.Event is part of the public API (although undocumented). Make it
-  // lazily evalulate to Event from event_bindings.js. For extensions only
-  // though, not all webpages!
-  if (context->extension()) {
-    v8::Local<v8::Object> chrome = AsObjectOrEmpty(GetOrCreateChrome(context));
-    if (!chrome.IsEmpty())
-      module_system->SetLazyField(chrome, "Event", kEventBindings, "Event");
-  }
-
+  bindings_system_->DidCreateScriptContext(context);
   UpdateBindingsForContext(context);
 
   bool is_within_platform_app = IsWithinPlatformApp();
   // Inject custom JS into the platform app context.
   if (is_within_platform_app) {
     module_system->Require("platformApp");
   }
 
   RequireGuestViewModules(context);
   delegate_->RequireAdditionalModules(context, is_within_platform_app);
@@ skipping 75 matching lines @@
     // won't work before that event has fired?
     return;
   }
 
   ScriptContext* context = new ScriptContext(
       v8_context, nullptr, extension, Feature::SERVICE_WORKER_CONTEXT,
       extension, Feature::SERVICE_WORKER_CONTEXT);
   context->set_url(url);
 
   if (ExtensionsClient::Get()->ExtensionAPIEnabledInExtensionServiceWorkers()) {
-    WorkerThreadDispatcher::Get()->AddWorkerData(service_worker_version_id);
-    {
-      // TODO(lazyboy): Make sure accessing |source_map_| in worker thread is
-      // safe.
-      std::unique_ptr<ModuleSystem> module_system(
-          new ModuleSystem(context, &source_map_));
-      context->set_module_system(std::move(module_system));
-    }
+    WorkerThreadDispatcher::Get()->AddWorkerData(service_worker_version_id,
+                                                 &source_map_);
+
+    // TODO(lazyboy): Make sure accessing |source_map_| in worker thread is
+    // safe.
+    context->set_module_system(
+        base::MakeUnique<ModuleSystem>(context, &source_map_));
 
     ModuleSystem* module_system = context->module_system();
     // Enable natives in startup.
     ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system);
-    RegisterNativeHandlers(
-        module_system, context,
-        WorkerThreadDispatcher::Get()->GetRequestSender(),
-        WorkerThreadDispatcher::Get()->GetV8SchemaRegistry());
-    // chrome.Event is part of the public API (although undocumented). Make it
-    // lazily evalulate to Event from event_bindings.js.
-    v8::Local<v8::Object> chrome = AsObjectOrEmpty(GetOrCreateChrome(context));
-    if (!chrome.IsEmpty())
-      module_system->SetLazyField(chrome, "Event", kEventBindings, "Event");
+    ExtensionBindingsSystem* worker_bindings_system =
+        WorkerThreadDispatcher::GetBindingsSystem();
+    RegisterNativeHandlers(module_system, context,
+                           worker_bindings_system->GetRequestSender(),
+                           WorkerThreadDispatcher::GetV8SchemaRegistry());
 
-    UpdateBindingsForContext(context);
+    worker_bindings_system->DidCreateScriptContext(context);
+    worker_bindings_system->UpdateBindingsForContext(context);
+
     // TODO(lazyboy): Get rid of RequireGuestViewModules() as this doesn't seem
     // necessary for Extension SW.
     RequireGuestViewModules(context);
     delegate_->RequireAdditionalModules(context,
                                         false /* is_within_platform_app */);
   }
 
   g_worker_script_context_set.Get().Insert(base::WrapUnique(context));
 
   v8::Isolate* isolate = context->isolate();
@@ skipping 39 matching lines @@
       "Extensions.DidInitializeServiceWorkerContextOnWorkerThread", elapsed);
 }
 
 void Dispatcher::WillReleaseScriptContext(
     blink::WebLocalFrame* frame,
     const v8::Local<v8::Context>& v8_context,
     int world_id) {
   ScriptContext* context = script_context_set_->GetByV8Context(v8_context);
   if (!context)
     return;
-
-  // TODO(kalman): Make |request_sender| use |context->AddInvalidationObserver|.
-  // In fact |request_sender_| should really be owned by ScriptContext.
-  request_sender_->InvalidateSource(context);
+  bindings_system_->WillReleaseScriptContext(context);
 
   script_context_set_->Remove(context);
   VLOG(1) << "Num tracked contexts: " << script_context_set_->size();
 }
 
 // static
 void Dispatcher::WillDestroyServiceWorkerContextOnWorkerThread(
     v8::Local<v8::Context> v8_context,
     int64_t service_worker_version_id,
     const GURL& url) {
   if (url.SchemeIs(kExtensionScheme) ||
       url.SchemeIs(kExtensionResourceScheme)) {
     // See comment in DidInitializeServiceWorkerContextOnWorkerThread.
     g_worker_script_context_set.Get().Remove(v8_context, url);
+    // TODO(devlin): We're not calling
+    // ExtensionBindingsSystem::WillReleaseScriptContext() here. This should be
+    // fine, since the entire bindings system is being destroyed when we
+    // remove the worker data, but we might want to notify the system anyway.
   }
   if (ExtensionsClient::Get()->ExtensionAPIEnabledInExtensionServiceWorkers())
     WorkerThreadDispatcher::Get()->RemoveWorkerData(service_worker_version_id);
 }
 
 void Dispatcher::DidCreateDocumentElement(blink::WebLocalFrame* frame) {
   // Note: use GetEffectiveDocumentURL not just frame->document()->url()
   // so that this also injects the stylesheet on about:blank frames that
   // are hosted in the extension process.
   GURL effective_document_url = ScriptContext::GetEffectiveDocumentURL(
@@ skipping 56 matching lines @@
     return;  // The frame is invisible to extensions.
 
   frame_helper->RunScriptsAtDocumentEnd();
   // |frame_helper| and |render_frame| might be dead by now.
 }
 
 void Dispatcher::OnExtensionResponse(int request_id,
                                      bool success,
                                      const base::ListValue& response,
                                      const std::string& error) {
-  request_sender_->HandleResponse(request_id, success, response, error);
+  bindings_system_->HandleResponse(request_id, success, response, error);
 }
 
 void Dispatcher::DispatchEvent(
     const std::string& extension_id,
     const std::string& event_name,
     const base::ListValue& event_args,
     const base::DictionaryValue& filtering_info) const {
-  script_context_set_->ForEach(extension_id, nullptr,
-                               base::Bind(&DispatchEventInContext, event_name,
-                                          &event_args, &filtering_info));
+  script_context_set_->ForEach(
+      extension_id, nullptr,
+      base::Bind(&ExtensionBindingsSystem::DispatchEventInContext,
+                 base::Unretained(bindings_system_.get()), event_name,
+                 &event_args, &filtering_info));
 
   // Reset the idle handler each time there's any activity like event or message
   // dispatch.
   // TODO(devlin): It's likely this is totally wrong. See
   // https://groups.google.com/a/chromium.org/forum/#!msg/scheduler-dev/iTRVbcmmpAs/pfqyUyEeAAAJ
   if (set_idle_notifications_) {
     RenderThread::Get()->ScheduleIdleHandler(
         kInitialExtensionIdleHandlerDelayMs);
   }
 }
@@ skipping 355 matching lines @@
 void Dispatcher::OnCancelSuspend(const std::string& extension_id) {
   DispatchEvent(extension_id, kOnSuspendCanceledEvent, base::ListValue(),
                 base::DictionaryValue());
 }
 
 void Dispatcher::OnDeliverMessage(int target_port_id,
                                   int source_tab_id,
                                   const Message& message) {
   std::unique_ptr<RequestSender::ScopedTabID> scoped_tab_id;
   if (source_tab_id != -1) {
-    scoped_tab_id.reset(
-        new RequestSender::ScopedTabID(request_sender(), source_tab_id));
+    scoped_tab_id.reset(new RequestSender::ScopedTabID(
+        bindings_system_->GetRequestSender(), source_tab_id));
   }
 
   MessagingBindings::DeliverMessage(*script_context_set_, target_port_id,
                                     message,
                                     NULL);  // All render frames.
 }
 
 void Dispatcher::OnDispatchOnConnect(
     int target_port_id,
     const std::string& channel_name,
@@ skipping 151 matching lines @@
   // If the extension is later reloaded with a different set of permissions,
   // we'd like it to get a new isolated world ID, so that it can pick up the
   // changed origin whitelist.
   ScriptInjection::RemoveIsolatedWorld(id);
 
   // Invalidate all of the contexts that were removed.
   // TODO(kalman): add an invalidation observer interface to ScriptContext.
   std::set<ScriptContext*> removed_contexts =
       script_context_set_->OnExtensionUnloaded(id);
   for (ScriptContext* context : removed_contexts) {
-    request_sender_->InvalidateSource(context);
+    bindings_system_->WillReleaseScriptContext(context);
   }
 
   // Update the available bindings for the remaining contexts. These may have
   // changed if an externally_connectable extension is unloaded and a webpage
   // is no longer accessible.
   UpdateBindings("");
 
   // Invalidates the messages map for the extension in case the extension is
   // reloaded with a new messages map.
   EraseL10nMessagesMap(id);
@@ skipping 153 matching lines @@
   blink::WebCustomElement::addEmbedderCustomElementName("webview");
   blink::WebCustomElement::addEmbedderCustomElementName("webviewbrowserplugin");
 }
 
 void Dispatcher::UpdateBindings(const std::string& extension_id) {
   script_context_set().ForEach(extension_id,
                                base::Bind(&Dispatcher::UpdateBindingsForContext,
                                           base::Unretained(this)));
 }
 
-// Note: this function runs on multiple threads: main renderer thread and
-// service worker threads.
 void Dispatcher::UpdateBindingsForContext(ScriptContext* context) {
-  v8::HandleScope handle_scope(context->isolate());
-  v8::Context::Scope context_scope(context->v8_context());
-
-  // 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);
-      if (context->GetAvailability("webstore").is_available())
-        RegisterBinding("webstore", context);
-      if (context->GetAvailability("dashboardPrivate").is_available())
-        RegisterBinding("dashboardPrivate", context);
-      if (IsRuntimeAvailableToContext(context))
-        RegisterBinding("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:
-    case Feature::WEBUI_CONTEXT: {
-      // Extension context; iterate through all the APIs and bind the available
-      // ones.
-      const FeatureProvider* api_feature_provider =
-          FeatureProvider::GetAPIFeatures();
-      for (const auto& map_entry : api_feature_provider->GetAllFeatures()) {
-        // Internal APIs are included via require(api_name) from internal code
-        // rather than chrome[api_name].
-        if (map_entry.second->IsInternal())
-          continue;
-
-        // If this API has a parent feature (and isn't marked 'noparent'),
-        // then this must be a function or event, so we should not register.
-        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)) {
-          // TODO(lazyboy): RegisterBinding() uses |source_map_|, any thread
-          // safety issue?
-          RegisterBinding(map_entry.first, context);
-        }
-      }
-      break;
-    }
+  bindings_system_->UpdateBindingsForContext(context);
+  Feature::Context context_type = context->context_type();
+  if (context_type == Feature::WEB_PAGE_CONTEXT ||
+      context_type == Feature::BLESSED_WEB_PAGE_CONTEXT) {
+    UpdateContentCapabilities(context);
   }
 }
 
-void Dispatcher::RegisterBinding(const std::string& api_name,
-                                 ScriptContext* context) {
-  std::string bind_name;
-  v8::Local<v8::Object> bind_object =
-      GetOrCreateBindObjectIfAvailable(api_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,
-        std::unique_ptr<NativeHandler>(
-            new BindingGeneratingNativeHandler(context, api_name, "binding")));
-    module_system->SetNativeLazyField(
-        bind_object, bind_name, api_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) {
   RegisterNativeHandlers(module_system, context, this, request_sender,
                          v8_schema_registry);
   const Extension* extension = context->extension();
   int manifest_version = extension ? extension->manifest_version() : 1;
   bool is_component_extension =
       extension && Manifest::IsComponentLocation(extension->location());
   bool send_request_disabled =
       (extension && Manifest::IsUnpackedLocation(extension->location()) &&
        BackgroundInfo::HasLazyBackgroundPage(extension));
   module_system->RegisterNativeHandler(
       "process",
       std::unique_ptr<NativeHandler>(new ProcessInfoNativeHandler(
           context, context->GetExtensionID(),
           context->GetContextTypeDescription(),
           ExtensionsRendererClient::Get()->IsIncognitoProcess(),
           is_component_extension, manifest_version, send_request_disabled)));
 
   delegate_->RegisterNativeHandlers(this, module_system, context);
 }
 
-bool Dispatcher::IsRuntimeAvailableToContext(ScriptContext* context) {
-  for (const auto& extension :
-       *RendererExtensionRegistry::Get()->GetMainThreadExtensionSet()) {
-    ExternallyConnectableInfo* info = static_cast<ExternallyConnectableInfo*>(
-        extension->GetManifestData(manifest_keys::kExternallyConnectable));
-    if (info && info->matches.MatchesURL(context->url()))
-      return true;
-  }
-  return false;
-}
-
 void Dispatcher::UpdateContentCapabilities(ScriptContext* context) {
   APIPermissionSet permissions;
   for (const auto& extension :
        *RendererExtensionRegistry::Get()->GetMainThreadExtensionSet()) {
     blink::WebLocalFrame* web_frame = context->web_frame();
     GURL url = context->url();
     // We allow about:blank pages to take on the privileges of their parents if
     // they aren't sandboxed.
     if (web_frame && !web_frame->getSecurityOrigin().isUnique())
       url = ScriptContext::GetEffectiveDocumentURL(web_frame, url, true);
@@ skipping 24 matching lines @@
        iter != active_extension_ids_.end();
        ++iter) {
     const Extension* extension =
         RendererExtensionRegistry::Get()->GetByID(*iter);
     if (extension && extension->is_platform_app())
       return true;
   }
   return false;
 }
 
-// static.
-v8::Local<v8::Object> Dispatcher::GetOrCreateObject(
-    const v8::Local<v8::Object>& object,
-    const std::string& field,
-    v8::Isolate* isolate) {
-  v8::Local<v8::String> key = v8::String::NewFromUtf8(isolate, field.c_str());
-  // If the object has a callback property, it is assumed it is an unavailable
-  // API, so it is safe to delete. This is checked before GetOrCreateObject is
-  // called.
-  if (object->HasRealNamedCallbackProperty(key)) {
-    object->Delete(key);
-  } else if (object->HasRealNamedProperty(key)) {
-    v8::Local<v8::Value> value = object->Get(key);
-    CHECK(value->IsObject());
-    return v8::Local<v8::Object>::Cast(value);
-  }
-
-  v8::Local<v8::Object> new_object = v8::Object::New(isolate);
-  object->Set(key, new_object);
-  return new_object;
-}
-
-// static.
-v8::Local<v8::Object> Dispatcher::GetOrCreateBindObjectIfAvailable(
-    const std::string& api_name,
-    std::string* bind_name,
-    ScriptContext* context) {
-  std::vector<std::string> split = base::SplitString(
-      api_name, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-
-  v8::Local<v8::Object> bind_object;
-
-  // Check if this API has an ancestor. If the API's ancestor is available and
-  // the API is not available, don't install the bindings for this API. If
-  // the API is available and its ancestor is not, delete the ancestor and
-  // install the bindings for the API. This is to prevent loading the ancestor
-  // API schema if it will not be needed.
-  //
-  // For example:
-  //  If app is available and app.window is not, just install app.
-  //  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()) {
-      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());
-  }
-
-  if (only_ancestor_available)
-    return v8::Local<v8::Object>();
-
-  if (bind_name)
-    *bind_name = split.back();
-
-  return bind_object.IsEmpty() ? AsObjectOrEmpty(GetOrCreateChrome(context))
-                               : bind_object;
-}
-
 void Dispatcher::RequireGuestViewModules(ScriptContext* context) {
   Feature::Context context_type = context->context_type();
   ModuleSystem* module_system = context->module_system();
   bool requires_guest_view_module = false;
 
   // Require AppView.
   if (context->GetAvailability("appViewEmbedderInternal").is_available()) {
     requires_guest_view_module = true;
     module_system->Require("appView");
   }
@@ skipping 30 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