Begin to enable extension APIs in Extension Service Worker.

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 <utility>
 
@@ skipping 23 matching lines @@
 #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_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"
@@ skipping 37 matching lines @@
 #include "extensions/renderer/set_icon_natives.h"
 #include "extensions/renderer/static_v8_external_one_byte_string_resource.h"
 #include "extensions/renderer/test_features_native_handler.h"
 #include "extensions/renderer/test_native_handler.h"
 #include "extensions/renderer/user_gestures_native_handler.h"
 #include "extensions/renderer/utils_native_handler.h"
 #include "extensions/renderer/v8_context_native_handler.h"
 #include "extensions/renderer/v8_helpers.h"
 #include "extensions/renderer/wake_event_page.h"
 #include "extensions/renderer/worker_script_context_set.h"
+#include "extensions/renderer/worker_thread_dispatcher.h"
 #include "grit/extensions_renderer_resources.h"
 #include "mojo/public/js/constants.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebCustomElement.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
+#include "third_party/WebKit/public/web/WebScriptController.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
 
 using base::UserMetricsAction;
 using blink::WebDataSource;
 using blink::WebDocument;
 using blink::WebScopedUserGesture;
@@ skipping 103 matching lines @@
   }
 
   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(this));
   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());
 
   // WebSecurityPolicy whitelists. They should be registered for both
   // chrome-extension: and chrome-extension-resource.
   using RegisterFunction = void (*)(const WebString&);
   RegisterFunction register_functions[] = {
       // Treat as secure because communication with them is entirely in the
       // browser, so there is no danger of manipulation or eavesdropping on
       // communication with them by third parties.
@@ skipping 78 matching lines @@
   {
     scoped_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);
+  RegisterNativeHandlers(module_system, context, request_sender_.get(),
+                         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");
   }
 
@@ skipping 38 matching lines @@
     case Feature::SERVICE_WORKER_CONTEXT:
       // Handled in DidInitializeServiceWorkerContextOnWorkerThread().
       NOTREACHED();
       break;
   }
 
   VLOG(1) << "Num tracked contexts: " << script_context_set_->size();
 }
 
 // static
+void Dispatcher::InstallV8ExtensionForServiceWorkers() {
+  if (feature_util::ExtensionAPIEnabledInExtensionServiceWorkers()) {
+    blink::WebScriptController::registerExtensionForServiceWorkerScript(
+        SafeBuiltins::CreateV8Extension());
+  }
+}
+
 void Dispatcher::DidInitializeServiceWorkerContextOnWorkerThread(
     v8::Local<v8::Context> v8_context,
+    int embedded_worker_id,
     const GURL& url) {
   const base::TimeTicks start_time = base::TimeTicks::Now();
 
   if (!url.SchemeIs(kExtensionScheme) &&
       !url.SchemeIs(kExtensionResourceScheme)) {
     // Early-out if this isn't a chrome-extension:// or resource scheme,
     // because looking up the extension registry is unnecessary if it's not.
     // Checking this will also skip over hosted apps, which is the desired
     // behavior - hosted app service workers are not our concern.
     return;
@@ skipping 24 matching lines @@
     // saying that an extension is ready, and documenting that extension APIs
     // 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 (feature_util::ExtensionAPIEnabledInExtensionServiceWorkers()) {
+    WorkerThreadDispatcher::Get()->AddWorkerData(embedded_worker_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));
+    }
+
+    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");
+
+    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(make_scoped_ptr(context));
 
   v8::Isolate* isolate = context->isolate();
 
   // Fetch the source code for service_worker_bindings.js.
   base::StringPiece script_resource =
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_SERVICE_WORKER_BINDINGS_JS);
   v8::Local<v8::String> script = v8::String::NewExternal(
       isolate, new StaticV8ExternalOneByteStringResource(script_resource));
@@ skipping 44 matching lines @@
   // In fact |request_sender_| should really be owned by ScriptContext.
   request_sender_->InvalidateSource(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,
+    int embedded_worker_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);
   }
+  if (feature_util::ExtensionAPIEnabledInExtensionServiceWorkers())
+    WorkerThreadDispatcher::Get()->RemoveWorkerData(embedded_worker_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(
       frame, frame->document().url(), true /* match_about_blank */);
 
   const Extension* extension =
@@ skipping 392 matching lines @@
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(Dispatcher, message)
   IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateExtension, OnActivateExtension)
   IPC_MESSAGE_HANDLER(ExtensionMsg_CancelSuspend, OnCancelSuspend)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DeliverMessage, OnDeliverMessage)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnConnect, OnDispatchOnConnect)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnDisconnect, OnDispatchOnDisconnect)
   IPC_MESSAGE_HANDLER(ExtensionMsg_Loaded, OnLoaded)
   IPC_MESSAGE_HANDLER(ExtensionMsg_MessageInvoke, OnMessageInvoke)
   IPC_MESSAGE_HANDLER(ExtensionMsg_SetChannel, OnSetChannel)
+  IPC_MESSAGE_HANDLER(
+      ExtensionMsg_SetExtensionAPIEnabledInExtensionServiceWorkers,
+      OnSetExtensionAPIEnabledInExtensionServiceWorkers)
   IPC_MESSAGE_HANDLER(ExtensionMsg_SetScriptingWhitelist,
                       OnSetScriptingWhitelist)
   IPC_MESSAGE_HANDLER(ExtensionMsg_SetSystemFont, OnSetSystemFont)
   IPC_MESSAGE_HANDLER(ExtensionMsg_SetWebViewPartitionID,
                       OnSetWebViewPartitionID)
   IPC_MESSAGE_HANDLER(ExtensionMsg_ShouldSuspend, OnShouldSuspend)
   IPC_MESSAGE_HANDLER(ExtensionMsg_Suspend, OnSuspend)
   IPC_MESSAGE_HANDLER(ExtensionMsg_TransferBlobs, OnTransferBlobs)
   IPC_MESSAGE_HANDLER(ExtensionMsg_Unloaded, OnUnloaded)
   IPC_MESSAGE_HANDLER(ExtensionMsg_UpdatePermissions, OnUpdatePermissions)
@@ skipping 154 matching lines @@
                                  const base::ListValue& args,
                                  bool user_gesture) {
   InvokeModuleSystemMethod(
       NULL, extension_id, module_name, function_name, args, user_gesture);
 }
 
 void Dispatcher::OnSetChannel(int channel) {
   delegate_->SetChannel(channel);
 }
 
+void Dispatcher::OnSetExtensionAPIEnabledInExtensionServiceWorkers(
+    bool enabled) {
+  feature_util::SetExtensionAPIEnabledInExtensionServiceWorkers(enabled);
+}
+
 void Dispatcher::OnSetScriptingWhitelist(
     const ExtensionsClient::ScriptingWhitelist& extension_ids) {
   ExtensionsClient::Get()->SetScriptingWhitelist(extension_ids);
 }
 
 void Dispatcher::OnSetSystemFont(const std::string& font_family,
                                  const std::string& font_size) {
   system_font_family_ = font_family;
   system_font_size_ = font_size;
 }
@@ skipping 206 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(feature_util::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.get()))
+        if (context->IsAnyFeatureAvailableToContext(*map_entry.second.get())) {
+          // TODO(lazyboy): RegisterBinding() uses |source_map_|, any thread
+          // safety issue?
           RegisterBinding(map_entry.first, context);
+        }
       }
       break;
     }
-    case Feature::SERVICE_WORKER_CONTEXT:
-      // Handled in DidInitializeServiceWorkerContextOnWorkerThread().
-      NOTREACHED();
-      break;
   }
 }
 
 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
@@ skipping 27 matching lines @@
             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) {
-  RegisterNativeHandlers(module_system,
-                         context,
-                         this,
-                         request_sender_.get(),
-                         v8_schema_registry_.get());
+                                        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",
       scoped_ptr<NativeHandler>(new ProcessInfoNativeHandler(
@@ skipping 50 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
@@ skipping 90 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