diff options
Diffstat (limited to 'chromium/extensions/renderer/dispatcher.cc')
| -rw-r--r-- | chromium/extensions/renderer/dispatcher.cc | 1629 |
1 files changed, 1629 insertions, 0 deletions
diff --git a/chromium/extensions/renderer/dispatcher.cc b/chromium/extensions/renderer/dispatcher.cc new file mode 100644 index 00000000000..60a4a11bfec --- /dev/null +++ b/chromium/extensions/renderer/dispatcher.cc @@ -0,0 +1,1629 @@ +// 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> + +#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/lazy_instance.h" +#include "base/macros.h" +#include "base/memory/scoped_ptr.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/browser_plugin_guest_mode.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_provider.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/css_native_handler.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/i18n_custom_bindings.h" +#include "extensions/renderer/id_generator_custom_bindings.h" +#include "extensions/renderer/lazy_background_page_native_handler.h" +#include "extensions/renderer/logging_native_handler.h" +#include "extensions/renderer/messaging_bindings.h" +#include "extensions/renderer/module_system.h" +#include "extensions/renderer/print_native_handler.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" +#include "extensions/renderer/script_context_set.h" +#include "extensions/renderer/script_injection.h" +#include "extensions/renderer/script_injection_manager.h" +#include "extensions/renderer/send_request_natives.h" +#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 "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/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; +using blink::WebSecurityPolicy; +using blink::WebString; +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()); + + scoped_ptr<content::V8ValueConverter> converter( + content::V8ValueConverter::create()); + + std::vector<v8::Local<v8::Value>> arguments; + for (base::ListValue::const_iterator it = args->begin(); it != args->end(); + ++it) { + arguments.push_back(converter->ToV8Value(*it, context->v8_context())); + } + + context->module_system()->CallModuleMethod( + module_name, method_name, &arguments); +} + +// This handles the "chrome." root API object in script contexts. +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())); + } +}; + +base::LazyInstance<WorkerScriptContextSet> g_worker_script_context_set = + LAZY_INSTANCE_INITIALIZER; + +} // 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), + user_script_set_manager_observer_(this), + webrequest_used_(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(this)); + PopulateSourceMap(); + WakeEventPage::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. + WebSecurityPolicy::registerURLSchemeAsSecure, + // As far as Blink is concerned, they should be allowed to receive CORS + // requests. At the Extensions layer, requests will actually be blocked + // unless overridden by the web_accessible_resources manifest key. + // TODO(kalman): See what happens with a service worker. + WebSecurityPolicy::registerURLSchemeAsCORSEnabled, + // Resources should bypass Content Security Policy checks when included in + // protected resources. TODO(kalman): What are "protected resources"? + WebSecurityPolicy::registerURLSchemeAsBypassingContentSecurityPolicy, + // Extension resources are HTTP-like and safe to expose to the fetch API. + // The rules for the fetch API are consistent with XHR. + WebSecurityPolicy::registerURLSchemeAsSupportingFetchAPI, + // Extension resources, when loaded as the top-level document, should + // bypass Blink's strict first-party origin checks. + WebSecurityPolicy::registerURLSchemeAsFirstPartyWhenTopLevel, + }; + + WebString extension_scheme(base::ASCIIToUTF16(kExtensionScheme)); + WebString extension_resource_scheme(base::ASCIIToUTF16( + kExtensionResourceScheme)); + for (RegisterFunction func : register_functions) { + func(extension_scheme); + func(extension_resource_scheme); + } + + // For extensions, we want to ensure we call the IdleHandler every so often, + // even if the extension keeps up activity. + if (set_idle_notifications_) { + forced_idle_timer_.reset(new base::RepeatingTimer); + forced_idle_timer_->Start( + FROM_HERE, + base::TimeDelta::FromMilliseconds(kMaxExtensionIdleHandlerDelayMs), + RenderThread::Get(), + &RenderThread::IdleHandler); + } + + // Initialize host permissions for any extensions that were activated before + // WebKit was initialized. + for (const std::string& extension_id : active_extension_ids_) { + const Extension* extension = + RendererExtensionRegistry::Get()->GetByID(extension_id); + CHECK(extension); + InitOriginPermissions(extension); + } + + EnableCustomElementWhiteList(); +} + +Dispatcher::~Dispatcher() { +} + +void Dispatcher::OnRenderFrameCreated(content::RenderFrame* render_frame) { + script_injection_manager_->OnRenderFrameCreated(render_frame); +} + +bool Dispatcher::IsExtensionActive(const std::string& extension_id) const { + bool is_active = + active_extension_ids_.find(extension_id) != active_extension_ids_.end(); + if (is_active) + CHECK(RendererExtensionRegistry::Get()->Contains(extension_id)); + return is_active; +} + +void Dispatcher::DidCreateScriptContext( + blink::WebLocalFrame* frame, + const v8::Local<v8::Context>& v8_context, + int extension_group, + int world_id) { + const base::TimeTicks start_time = base::TimeTicks::Now(); + + ScriptContext* context = script_context_set_->Register( + frame, v8_context, extension_group, world_id); + + // Initialize origin permissions for content scripts, which can't be + // initialized in |OnActivateExtension|. + if (context->context_type() == Feature::CONTENT_SCRIPT_CONTEXT) + InitOriginPermissions(context->extension()); + + { + 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); + + // 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"); + } + + 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); + + const base::TimeDelta elapsed = base::TimeTicks::Now() - start_time; + switch (context->context_type()) { + case Feature::UNSPECIFIED_CONTEXT: + UMA_HISTOGRAM_TIMES("Extensions.DidCreateScriptContext_Unspecified", + elapsed); + break; + case Feature::BLESSED_EXTENSION_CONTEXT: + UMA_HISTOGRAM_TIMES("Extensions.DidCreateScriptContext_Blessed", elapsed); + break; + case Feature::UNBLESSED_EXTENSION_CONTEXT: + UMA_HISTOGRAM_TIMES("Extensions.DidCreateScriptContext_Unblessed", + elapsed); + break; + case Feature::CONTENT_SCRIPT_CONTEXT: + UMA_HISTOGRAM_TIMES("Extensions.DidCreateScriptContext_ContentScript", + elapsed); + break; + case Feature::WEB_PAGE_CONTEXT: + UMA_HISTOGRAM_TIMES("Extensions.DidCreateScriptContext_WebPage", elapsed); + break; + case Feature::BLESSED_WEB_PAGE_CONTEXT: + UMA_HISTOGRAM_TIMES("Extensions.DidCreateScriptContext_BlessedWebPage", + elapsed); + break; + case Feature::WEBUI_CONTEXT: + UMA_HISTOGRAM_TIMES("Extensions.DidCreateScriptContext_WebUI", elapsed); + break; + case Feature::SERVICE_WORKER_CONTEXT: + // Handled in DidInitializeServiceWorkerContextOnWorkerThread(). + NOTREACHED(); + break; + } + + VLOG(1) << "Num tracked contexts: " << script_context_set_->size(); +} + +// static +void Dispatcher::DidInitializeServiceWorkerContextOnWorkerThread( + v8::Local<v8::Context> v8_context, + 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; + } + + const Extension* extension = + RendererExtensionRegistry::Get()->GetExtensionOrAppByURL(url); + + if (!extension) { + // TODO(kalman): This is no good. Instead we need to either: + // + // - Hold onto the v8::Context and create the ScriptContext and install + // our bindings when this extension is loaded. + // - Deal with there being an extension ID (url.host()) but no + // extension associated with it, then document that getBackgroundClient + // may fail if the extension hasn't loaded yet. + // + // The former is safer, but is unfriendly to caching (e.g. session restore). + // It seems to contradict the service worker idiom. + // + // The latter is friendly to caching, but running extension code without an + // installed extension makes me nervous, and means that we won't be able to + // expose arbitrary (i.e. capability-checked) extension APIs to service + // workers. We will probably need to relax some assertions - we just need + // to find them. + // + // Perhaps this could be solved with our own event on the service worker + // 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); + + 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)); + + // Run service_worker.js to get the main function. + v8::Local<v8::Function> main_function; + { + v8::Local<v8::Value> result = context->RunScript( + v8_helpers::ToV8StringUnsafe(isolate, "service_worker"), script, + base::Bind(&CrashOnException)); + CHECK(result->IsFunction()); + main_function = result.As<v8::Function>(); + } + + // Expose CHECK/DCHECK/NOTREACHED to the main function with a + // LoggingNativeHandler. Admire the neat base::Bind trick to both Invalidate + // and delete the native handler. + LoggingNativeHandler* logging = new LoggingNativeHandler(context); + context->AddInvalidationObserver( + base::Bind(&NativeHandler::Invalidate, base::Owned(logging))); + + // Execute the main function with its dependencies passed in as arguments. + v8::Local<v8::Value> args[] = { + // The extension's background URL. + v8_helpers::ToV8StringUnsafe( + isolate, BackgroundInfo::GetBackgroundURL(extension).spec()), + // The wake-event-page native function. + WakeEventPage::Get()->GetForContext(context), + // The logging module. + logging->NewInstance(), + }; + context->CallFunction(main_function, arraysize(args), args); + + const base::TimeDelta elapsed = base::TimeTicks::Now() - start_time; + UMA_HISTOGRAM_TIMES( + "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); + + script_context_set_->Remove(context); + VLOG(1) << "Num tracked contexts: " << script_context_set_->size(); +} + +// static +void Dispatcher::WillDestroyServiceWorkerContextOnWorkerThread( + v8::Local<v8::Context> v8_context, + const GURL& url) { + if (url.SchemeIs(kExtensionScheme) || + url.SchemeIs(kExtensionResourceScheme)) { + // See comment in DidInitializeServiceWorkerContextOnWorkerThread. + g_worker_script_context_set.Get().Remove(v8_context, url); + } +} + +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 = + RendererExtensionRegistry::Get()->GetExtensionOrAppByURL( + effective_document_url); + + if (extension && + (extension->is_extension() || extension->is_platform_app())) { + int resource_id = extension->is_platform_app() ? IDR_PLATFORM_APP_CSS + : IDR_EXTENSION_FONTS_CSS; + std::string stylesheet = ResourceBundle::GetSharedInstance() + .GetRawDataResource(resource_id) + .as_string(); + base::ReplaceFirstSubstringAfterOffset( + &stylesheet, 0, "$FONTFAMILY", system_font_family_); + base::ReplaceFirstSubstringAfterOffset( + &stylesheet, 0, "$FONTSIZE", system_font_size_); + + // Blink doesn't let us define an additional user agent stylesheet, so + // we insert the default platform app or extension stylesheet into all + // documents that are loaded in each app or extension. + frame->document().insertStyleSheet(WebString::fromUTF8(stylesheet)); + } + + // If this is an extension options page, and the extension has opted into + // using Chrome styles, then insert the Chrome extension stylesheet. + if (extension && extension->is_extension() && + OptionsPageInfo::ShouldUseChromeStyle(extension) && + effective_document_url == OptionsPageInfo::GetOptionsPage(extension)) { + frame->document().insertStyleSheet( + WebString::fromUTF8(ResourceBundle::GetSharedInstance() + .GetRawDataResource(IDR_EXTENSION_CSS) + .as_string())); + } + + // In testing, the document lifetime events can happen after the render + // process shutdown event. + // See: http://crbug.com/21508 and http://crbug.com/500851 + if (content_watcher_) { + content_watcher_->DidCreateDocumentElement(frame); + } +} + +void Dispatcher::RunScriptsAtDocumentStart(content::RenderFrame* render_frame) { + ExtensionFrameHelper* frame_helper = ExtensionFrameHelper::Get(render_frame); + if (!frame_helper) + return; // The frame is invisible to extensions. + + frame_helper->RunScriptsAtDocumentStart(); + // |frame_helper| and |render_frame| might be dead by now. +} + +void Dispatcher::RunScriptsAtDocumentEnd(content::RenderFrame* render_frame) { + ExtensionFrameHelper* frame_helper = ExtensionFrameHelper::Get(render_frame); + if (!frame_helper) + 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); +} + +void Dispatcher::DispatchEvent(const std::string& extension_id, + const std::string& event_name) const { + base::ListValue args; + args.Set(0, new base::StringValue(event_name)); + args.Set(1, new base::ListValue()); + + // Needed for Windows compilation, since kEventBindings is declared extern. + const char* local_event_bindings = kEventBindings; + script_context_set_->ForEach( + extension_id, base::Bind(&CallModuleMethod, local_event_bindings, + kEventDispatchFunction, &args)); +} + +void Dispatcher::InvokeModuleSystemMethod(content::RenderFrame* render_frame, + const std::string& extension_id, + const std::string& module_name, + const std::string& function_name, + const base::ListValue& args, + bool user_gesture) { + scoped_ptr<WebScopedUserGesture> web_user_gesture; + if (user_gesture) + web_user_gesture.reset(new WebScopedUserGesture); + + script_context_set_->ForEach( + extension_id, render_frame, + base::Bind(&CallModuleMethod, module_name, function_name, &args)); + + // Reset the idle handler each time there's any activity like event or message + // dispatch, for which Invoke is the chokepoint. + if (set_idle_notifications_) { + RenderThread::Get()->ScheduleIdleHandler( + kInitialExtensionIdleHandlerDelayMs); + } + + // Tell the browser process when an event has been dispatched with a lazy + // background page active. + const Extension* extension = + RendererExtensionRegistry::Get()->GetByID(extension_id); + if (extension && BackgroundInfo::HasLazyBackgroundPage(extension) && + module_name == kEventBindings && + function_name == kEventDispatchFunction) { + content::RenderFrame* background_frame = + ExtensionFrameHelper::GetBackgroundPageFrame(extension_id); + if (background_frame) { + int message_id; + args.GetInteger(3, &message_id); + background_frame->Send(new ExtensionHostMsg_EventAck( + background_frame->GetRoutingID(), message_id)); + } + } +} + +void Dispatcher::ClearPortData(int port_id) { + // Only the target port side has entries in |port_to_tab_id_map_|. If + // |port_id| is a source port, std::map::erase() will just silently fail + // here as a no-op. + port_to_tab_id_map_.erase(port_id); +} + +// static +std::vector<std::pair<std::string, int> > Dispatcher::GetJsResources() { + std::vector<std::pair<std::string, int> > resources; + + // Libraries. + resources.push_back(std::make_pair("appView", IDR_APP_VIEW_JS)); + resources.push_back(std::make_pair("entryIdManager", IDR_ENTRY_ID_MANAGER)); + resources.push_back(std::make_pair(kEventBindings, IDR_EVENT_BINDINGS_JS)); + resources.push_back(std::make_pair("extensionOptions", + IDR_EXTENSION_OPTIONS_JS)); + resources.push_back(std::make_pair("extensionOptionsAttributes", + IDR_EXTENSION_OPTIONS_ATTRIBUTES_JS)); + resources.push_back(std::make_pair("extensionOptionsConstants", + IDR_EXTENSION_OPTIONS_CONSTANTS_JS)); + resources.push_back(std::make_pair("extensionOptionsEvents", + IDR_EXTENSION_OPTIONS_EVENTS_JS)); + resources.push_back(std::make_pair("extensionView", IDR_EXTENSION_VIEW_JS)); + resources.push_back(std::make_pair("extensionViewApiMethods", + IDR_EXTENSION_VIEW_API_METHODS_JS)); + resources.push_back(std::make_pair("extensionViewAttributes", + IDR_EXTENSION_VIEW_ATTRIBUTES_JS)); + resources.push_back(std::make_pair("extensionViewConstants", + IDR_EXTENSION_VIEW_CONSTANTS_JS)); + resources.push_back(std::make_pair("extensionViewEvents", + IDR_EXTENSION_VIEW_EVENTS_JS)); + resources.push_back(std::make_pair( + "extensionViewInternal", IDR_EXTENSION_VIEW_INTERNAL_CUSTOM_BINDINGS_JS)); + resources.push_back(std::make_pair("guestView", IDR_GUEST_VIEW_JS)); + resources.push_back(std::make_pair("guestViewAttributes", + IDR_GUEST_VIEW_ATTRIBUTES_JS)); + resources.push_back(std::make_pair("guestViewContainer", + IDR_GUEST_VIEW_CONTAINER_JS)); + resources.push_back(std::make_pair("guestViewDeny", IDR_GUEST_VIEW_DENY_JS)); + resources.push_back(std::make_pair("guestViewEvents", + IDR_GUEST_VIEW_EVENTS_JS)); + + if (content::BrowserPluginGuestMode::UseCrossProcessFramesForGuests()) { + resources.push_back(std::make_pair("guestViewIframe", + IDR_GUEST_VIEW_IFRAME_JS)); + resources.push_back(std::make_pair("guestViewIframeContainer", + IDR_GUEST_VIEW_IFRAME_CONTAINER_JS)); + } + + resources.push_back(std::make_pair("imageUtil", IDR_IMAGE_UTIL_JS)); + resources.push_back(std::make_pair("json_schema", IDR_JSON_SCHEMA_JS)); + resources.push_back(std::make_pair("lastError", IDR_LAST_ERROR_JS)); + resources.push_back(std::make_pair("messaging", IDR_MESSAGING_JS)); + resources.push_back(std::make_pair("messaging_utils", + IDR_MESSAGING_UTILS_JS)); + resources.push_back(std::make_pair(kSchemaUtils, IDR_SCHEMA_UTILS_JS)); + resources.push_back(std::make_pair("sendRequest", IDR_SEND_REQUEST_JS)); + resources.push_back(std::make_pair("setIcon", IDR_SET_ICON_JS)); + resources.push_back(std::make_pair("test", IDR_TEST_CUSTOM_BINDINGS_JS)); + resources.push_back( + std::make_pair("test_environment_specific_bindings", + IDR_BROWSER_TEST_ENVIRONMENT_SPECIFIC_BINDINGS_JS)); + resources.push_back(std::make_pair("uncaught_exception_handler", + IDR_UNCAUGHT_EXCEPTION_HANDLER_JS)); + resources.push_back(std::make_pair("utils", IDR_UTILS_JS)); + resources.push_back(std::make_pair("webRequest", + IDR_WEB_REQUEST_CUSTOM_BINDINGS_JS)); + resources.push_back( + std::make_pair("webRequestInternal", + IDR_WEB_REQUEST_INTERNAL_CUSTOM_BINDINGS_JS)); + // Note: webView not webview so that this doesn't interfere with the + // chrome.webview API bindings. + resources.push_back(std::make_pair("webView", IDR_WEB_VIEW_JS)); + resources.push_back(std::make_pair("webViewActionRequests", + IDR_WEB_VIEW_ACTION_REQUESTS_JS)); + resources.push_back(std::make_pair("webViewApiMethods", + IDR_WEB_VIEW_API_METHODS_JS)); + resources.push_back(std::make_pair("webViewAttributes", + IDR_WEB_VIEW_ATTRIBUTES_JS)); + resources.push_back(std::make_pair("webViewConstants", + IDR_WEB_VIEW_CONSTANTS_JS)); + resources.push_back(std::make_pair("webViewEvents", IDR_WEB_VIEW_EVENTS_JS)); + resources.push_back(std::make_pair("webViewInternal", + IDR_WEB_VIEW_INTERNAL_CUSTOM_BINDINGS_JS)); + resources.push_back( + std::make_pair("webViewExperimental", IDR_WEB_VIEW_EXPERIMENTAL_JS)); + resources.push_back( + std::make_pair(mojo::kBindingsModuleName, IDR_MOJO_BINDINGS_JS)); + resources.push_back( + std::make_pair(mojo::kBufferModuleName, IDR_MOJO_BUFFER_JS)); + resources.push_back( + std::make_pair(mojo::kCodecModuleName, IDR_MOJO_CODEC_JS)); + resources.push_back( + std::make_pair(mojo::kConnectionModuleName, IDR_MOJO_CONNECTION_JS)); + resources.push_back( + std::make_pair(mojo::kConnectorModuleName, IDR_MOJO_CONNECTOR_JS)); + resources.push_back( + std::make_pair(mojo::kRouterModuleName, IDR_MOJO_ROUTER_JS)); + resources.push_back( + std::make_pair(mojo::kUnicodeModuleName, IDR_MOJO_UNICODE_JS)); + resources.push_back( + std::make_pair(mojo::kValidatorModuleName, IDR_MOJO_VALIDATOR_JS)); + resources.push_back(std::make_pair("async_waiter", IDR_ASYNC_WAITER_JS)); + resources.push_back(std::make_pair("data_receiver", IDR_DATA_RECEIVER_JS)); + resources.push_back(std::make_pair("data_sender", IDR_DATA_SENDER_JS)); + resources.push_back(std::make_pair("keep_alive", IDR_KEEP_ALIVE_JS)); + resources.push_back(std::make_pair("extensions/common/mojo/keep_alive.mojom", + IDR_KEEP_ALIVE_MOJOM_JS)); + resources.push_back(std::make_pair("device/serial/data_stream.mojom", + IDR_DATA_STREAM_MOJOM_JS)); + resources.push_back( + std::make_pair("device/serial/data_stream_serialization.mojom", + IDR_DATA_STREAM_SERIALIZATION_MOJOM_JS)); + resources.push_back(std::make_pair("stash_client", IDR_STASH_CLIENT_JS)); + resources.push_back( + std::make_pair("extensions/common/mojo/stash.mojom", IDR_STASH_MOJOM_JS)); + + // Custom bindings. + resources.push_back( + std::make_pair("app.runtime", IDR_APP_RUNTIME_CUSTOM_BINDINGS_JS)); + resources.push_back( + std::make_pair("app.window", IDR_APP_WINDOW_CUSTOM_BINDINGS_JS)); + resources.push_back( + std::make_pair("declarativeWebRequest", + IDR_DECLARATIVE_WEBREQUEST_CUSTOM_BINDINGS_JS)); + resources.push_back( + std::make_pair("displaySource", + IDR_DISPLAY_SOURCE_CUSTOM_BINDINGS_JS)); + resources.push_back( + std::make_pair("contextMenus", IDR_CONTEXT_MENUS_CUSTOM_BINDINGS_JS)); + resources.push_back( + std::make_pair("contextMenusHandlers", IDR_CONTEXT_MENUS_HANDLERS_JS)); + resources.push_back( + std::make_pair("extension", IDR_EXTENSION_CUSTOM_BINDINGS_JS)); + resources.push_back(std::make_pair("i18n", IDR_I18N_CUSTOM_BINDINGS_JS)); + resources.push_back(std::make_pair( + "mimeHandlerPrivate", IDR_MIME_HANDLER_PRIVATE_CUSTOM_BINDINGS_JS)); + resources.push_back(std::make_pair("extensions/common/api/mime_handler.mojom", + IDR_MIME_HANDLER_MOJOM_JS)); + resources.push_back( + std::make_pair("mojoPrivate", IDR_MOJO_PRIVATE_CUSTOM_BINDINGS_JS)); + resources.push_back( + std::make_pair("permissions", IDR_PERMISSIONS_CUSTOM_BINDINGS_JS)); + resources.push_back(std::make_pair("printerProvider", + IDR_PRINTER_PROVIDER_CUSTOM_BINDINGS_JS)); + resources.push_back( + std::make_pair("runtime", IDR_RUNTIME_CUSTOM_BINDINGS_JS)); + resources.push_back(std::make_pair("windowControls", IDR_WINDOW_CONTROLS_JS)); + resources.push_back( + std::make_pair("webViewRequest", + IDR_WEB_VIEW_REQUEST_CUSTOM_BINDINGS_JS)); + resources.push_back(std::make_pair("binding", IDR_BINDING_JS)); + + if (base::CommandLine::ForCurrentProcess()->HasSwitch( + switches::kEnableMojoSerialService)) { + resources.push_back( + std::make_pair("serial", IDR_SERIAL_CUSTOM_BINDINGS_JS)); + } + resources.push_back(std::make_pair("serial_service", IDR_SERIAL_SERVICE_JS)); + resources.push_back( + std::make_pair("device/serial/serial.mojom", IDR_SERIAL_MOJOM_JS)); + resources.push_back(std::make_pair("device/serial/serial_serialization.mojom", + IDR_SERIAL_SERIALIZATION_MOJOM_JS)); + + // Custom types sources. + resources.push_back(std::make_pair("StorageArea", IDR_STORAGE_AREA_JS)); + + // Platform app sources that are not API-specific.. + resources.push_back(std::make_pair("platformApp", IDR_PLATFORM_APP_JS)); + +#if defined(ENABLE_MEDIA_ROUTER) + resources.push_back( + std::make_pair("chrome/browser/media/router/mojo/media_router.mojom", + IDR_MEDIA_ROUTER_MOJOM_JS)); + resources.push_back( + std::make_pair("media_router_bindings", IDR_MEDIA_ROUTER_BINDINGS_JS)); +#endif // defined(ENABLE_MEDIA_ROUTER) + + return resources; +} + +// NOTE: please use the naming convention "foo_natives" for these. +// static +void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system, + ScriptContext* context, + Dispatcher* dispatcher, + RequestSender* request_sender, + V8SchemaRegistry* v8_schema_registry) { + module_system->RegisterNativeHandler( + "chrome", scoped_ptr<NativeHandler>(new ChromeNativeHandler(context))); + module_system->RegisterNativeHandler( + "lazy_background_page", + scoped_ptr<NativeHandler>(new LazyBackgroundPageNativeHandler(context))); + module_system->RegisterNativeHandler( + "logging", scoped_ptr<NativeHandler>(new LoggingNativeHandler(context))); + module_system->RegisterNativeHandler("schema_registry", + v8_schema_registry->AsNativeHandler()); + module_system->RegisterNativeHandler( + "print", scoped_ptr<NativeHandler>(new PrintNativeHandler(context))); + module_system->RegisterNativeHandler( + "test_features", + scoped_ptr<NativeHandler>(new TestFeaturesNativeHandler(context))); + module_system->RegisterNativeHandler( + "test_native_handler", + scoped_ptr<NativeHandler>(new TestNativeHandler(context))); + module_system->RegisterNativeHandler( + "user_gestures", + scoped_ptr<NativeHandler>(new UserGesturesNativeHandler(context))); + module_system->RegisterNativeHandler( + "utils", scoped_ptr<NativeHandler>(new UtilsNativeHandler(context))); + module_system->RegisterNativeHandler( + "v8_context", + scoped_ptr<NativeHandler>(new V8ContextNativeHandler(context))); + module_system->RegisterNativeHandler( + "event_natives", scoped_ptr<NativeHandler>(new EventBindings(context))); + module_system->RegisterNativeHandler( + "messaging_natives", + scoped_ptr<NativeHandler>(MessagingBindings::Get(dispatcher, context))); + module_system->RegisterNativeHandler( + "apiDefinitions", + scoped_ptr<NativeHandler>( + new ApiDefinitionsNatives(dispatcher, context))); + module_system->RegisterNativeHandler( + "sendRequest", + scoped_ptr<NativeHandler>( + new SendRequestNatives(request_sender, context))); + module_system->RegisterNativeHandler( + "setIcon", + scoped_ptr<NativeHandler>(new SetIconNatives(context))); + module_system->RegisterNativeHandler( + "activityLogger", + scoped_ptr<NativeHandler>(new APIActivityLogger(context))); + module_system->RegisterNativeHandler( + "renderFrameObserverNatives", + scoped_ptr<NativeHandler>(new RenderFrameObserverNatives(context))); + + // Natives used by multiple APIs. + module_system->RegisterNativeHandler( + "file_system_natives", + scoped_ptr<NativeHandler>(new FileSystemNatives(context))); + + // Custom bindings. + module_system->RegisterNativeHandler( + "app_window_natives", + scoped_ptr<NativeHandler>(new AppWindowCustomBindings(context))); + module_system->RegisterNativeHandler( + "blob_natives", + scoped_ptr<NativeHandler>(new BlobNativeHandler(context))); + module_system->RegisterNativeHandler( + "context_menus", + scoped_ptr<NativeHandler>(new ContextMenusCustomBindings(context))); + module_system->RegisterNativeHandler( + "css_natives", scoped_ptr<NativeHandler>(new CssNativeHandler(context))); + module_system->RegisterNativeHandler( + "document_natives", + scoped_ptr<NativeHandler>(new DocumentCustomBindings(context))); + module_system->RegisterNativeHandler( + "guest_view_internal", + scoped_ptr<NativeHandler>( + new GuestViewInternalCustomBindings(context))); + module_system->RegisterNativeHandler( + "i18n", scoped_ptr<NativeHandler>(new I18NCustomBindings(context))); + module_system->RegisterNativeHandler( + "id_generator", + scoped_ptr<NativeHandler>(new IdGeneratorCustomBindings(context))); + module_system->RegisterNativeHandler( + "runtime", scoped_ptr<NativeHandler>(new RuntimeCustomBindings(context))); + module_system->RegisterNativeHandler( + "display_source", + scoped_ptr<NativeHandler>(new DisplaySourceCustomBindings(context))); +} + +bool Dispatcher::OnControlMessageReceived(const IPC::Message& message) { + 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_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) + IPC_MESSAGE_HANDLER(ExtensionMsg_UpdateTabSpecificPermissions, + OnUpdateTabSpecificPermissions) + IPC_MESSAGE_HANDLER(ExtensionMsg_ClearTabSpecificPermissions, + OnClearTabSpecificPermissions) + IPC_MESSAGE_HANDLER(ExtensionMsg_UsingWebRequestAPI, OnUsingWebRequestAPI) + IPC_MESSAGE_FORWARD(ExtensionMsg_WatchPages, + content_watcher_.get(), + ContentWatcher::OnWatchPages) + IPC_MESSAGE_UNHANDLED(handled = false) + IPC_END_MESSAGE_MAP() + + return handled; +} +void Dispatcher::IdleNotification() { + if (set_idle_notifications_ && forced_idle_timer_) { + // Dampen the forced delay as well if the extension stays idle for long + // periods of time. (forced_idle_timer_ can be NULL after + // OnRenderProcessShutdown has been called.) + int64_t forced_delay_ms = + std::max(RenderThread::Get()->GetIdleNotificationDelayInMs(), + kMaxExtensionIdleHandlerDelayMs); + forced_idle_timer_->Stop(); + forced_idle_timer_->Start( + FROM_HERE, + base::TimeDelta::FromMilliseconds(forced_delay_ms), + RenderThread::Get(), + &RenderThread::IdleHandler); + } +} + +void Dispatcher::OnRenderProcessShutdown() { + v8_schema_registry_.reset(); + forced_idle_timer_.reset(); + content_watcher_.reset(); + script_context_set_->ForEach( + std::string(), nullptr, + base::Bind(&ScriptContextSet::Remove, + base::Unretained(script_context_set_.get()))); +} + +void Dispatcher::OnActivateExtension(const std::string& extension_id) { + const Extension* extension = + RendererExtensionRegistry::Get()->GetByID(extension_id); + if (!extension) { + // Extension was activated but was never loaded. This probably means that + // the renderer failed to load it (or the browser failed to tell us when it + // did). Failures shouldn't happen, but instead of crashing there (which + // executes on all renderers) be conservative and only crash in the renderer + // of the extension which failed to load; this one. + std::string& error = extension_load_errors_[extension_id]; + char minidump[256]; + base::debug::Alias(&minidump); + base::snprintf(minidump, + arraysize(minidump), + "e::dispatcher:%s:%s", + extension_id.c_str(), + error.c_str()); + LOG(FATAL) << extension_id << " was never loaded: " << error; + } + + active_extension_ids_.insert(extension_id); + + // This is called when starting a new extension page, so start the idle + // handler ticking. + RenderThread::Get()->ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayMs); + + DOMActivityLogger::AttachToWorld( + DOMActivityLogger::kMainWorldId, extension_id); + + InitOriginPermissions(extension); + + UpdateActiveExtensions(); +} + +void Dispatcher::OnCancelSuspend(const std::string& extension_id) { + DispatchEvent(extension_id, kOnSuspendCanceledEvent); +} + +void Dispatcher::OnDeliverMessage(int target_port_id, const Message& message) { + scoped_ptr<RequestSender::ScopedTabID> scoped_tab_id; + std::map<int, int>::const_iterator it = + port_to_tab_id_map_.find(target_port_id); + if (it != port_to_tab_id_map_.end()) { + scoped_tab_id.reset( + new RequestSender::ScopedTabID(request_sender(), it->second)); + } + + 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, + const ExtensionMsg_TabConnectionInfo& source, + const ExtensionMsg_ExternalConnectionInfo& info, + const std::string& tls_channel_id) { + DCHECK(!ContainsKey(port_to_tab_id_map_, target_port_id)); + DCHECK_EQ(1, target_port_id % 2); // target renderer ports have odd IDs. + int sender_tab_id = -1; + source.tab.GetInteger("id", &sender_tab_id); + port_to_tab_id_map_[target_port_id] = sender_tab_id; + + MessagingBindings::DispatchOnConnect(*script_context_set_, target_port_id, + channel_name, source, info, + tls_channel_id, + NULL); // All render frames. +} + +void Dispatcher::OnDispatchOnDisconnect(int port_id, + const std::string& error_message) { + MessagingBindings::DispatchOnDisconnect(*script_context_set_, port_id, + error_message, + NULL); // All render frames. +} + +void Dispatcher::OnLoaded( + const std::vector<ExtensionMsg_Loaded_Params>& loaded_extensions) { + for (const auto& param : loaded_extensions) { + std::string error; + scoped_refptr<const Extension> extension = param.ConvertToExtension(&error); + if (!extension.get()) { + NOTREACHED() << error; + // Note: in tests |param.id| has been observed to be empty (see comment + // just below) so this isn't all that reliable. + extension_load_errors_[param.id] = error; + continue; + } + + RendererExtensionRegistry* extension_registry = + RendererExtensionRegistry::Get(); + // TODO(kalman): This test is deliberately not a CHECK (though I wish it + // could be) and uses extension->id() not params.id: + // 1. For some reason params.id can be empty. I've only seen it with + // the webstore extension, in tests, and I've spent some time trying to + // figure out why - but cost/benefit won. + // 2. The browser only sends this IPC to RenderProcessHosts once, but the + // Dispatcher is attached to a RenderThread. Presumably there is a + // mismatch there. In theory one would think it's possible for the + // browser to figure this out itself - but again, cost/benefit. + if (!extension_registry->Contains(extension->id())) + extension_registry->Insert(extension); + } + + // Update the available bindings for all contexts. These may have changed if + // an externally_connectable extension was loaded that can connect to an + // open webpage. + UpdateBindings(""); +} + +void Dispatcher::OnMessageInvoke(const std::string& extension_id, + const std::string& module_name, + const std::string& function_name, + 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::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; +} + +void Dispatcher::OnSetWebViewPartitionID(const std::string& partition_id) { + // |webview_partition_id_| cannot be changed once set. + CHECK(webview_partition_id_.empty() || webview_partition_id_ == partition_id); + webview_partition_id_ = partition_id; +} + +void Dispatcher::OnShouldSuspend(const std::string& extension_id, + uint64_t sequence_id) { + RenderThread::Get()->Send( + new ExtensionHostMsg_ShouldSuspendAck(extension_id, sequence_id)); +} + +void Dispatcher::OnSuspend(const std::string& extension_id) { + // Dispatch the suspend event. This doesn't go through the standard event + // dispatch machinery because it requires special handling. We need to let + // the browser know when we are starting and stopping the event dispatch, so + // that it still considers the extension idle despite any activity the suspend + // event creates. + DispatchEvent(extension_id, kOnSuspendEvent); + RenderThread::Get()->Send(new ExtensionHostMsg_SuspendAck(extension_id)); +} + +void Dispatcher::OnTransferBlobs(const std::vector<std::string>& blob_uuids) { + RenderThread::Get()->Send(new ExtensionHostMsg_TransferBlobsAck(blob_uuids)); +} + +void Dispatcher::OnUnloaded(const std::string& id) { + // See comment in OnLoaded for why it would be nice, but perhaps incorrect, + // to CHECK here rather than guarding. + if (!RendererExtensionRegistry::Get()->Remove(id)) + return; + + active_extension_ids_.erase(id); + + script_injection_manager_->OnExtensionUnloaded(id); + + // 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); + } + + // 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); + + // We don't do anything with existing platform-app stylesheets. They will + // stay resident, but the URL pattern corresponding to the unloaded + // extension's URL just won't match anything anymore. +} + +void Dispatcher::OnUpdatePermissions( + const ExtensionMsg_UpdatePermissions_Params& params) { + const Extension* extension = + RendererExtensionRegistry::Get()->GetByID(params.extension_id); + if (!extension) + return; + + scoped_ptr<const PermissionSet> active = + params.active_permissions.ToPermissionSet(); + scoped_ptr<const PermissionSet> withheld = + params.withheld_permissions.ToPermissionSet(); + + UpdateOriginPermissions( + extension->url(), + extension->permissions_data()->GetEffectiveHostPermissions(), + active->effective_hosts()); + + extension->permissions_data()->SetPermissions(std::move(active), + std::move(withheld)); + UpdateBindings(extension->id()); +} + +void Dispatcher::OnUpdateTabSpecificPermissions(const GURL& visible_url, + const std::string& extension_id, + const URLPatternSet& new_hosts, + bool update_origin_whitelist, + int tab_id) { + const Extension* extension = + RendererExtensionRegistry::Get()->GetByID(extension_id); + if (!extension) + return; + + URLPatternSet old_effective = + extension->permissions_data()->GetEffectiveHostPermissions(); + extension->permissions_data()->UpdateTabSpecificPermissions( + tab_id, + extensions::PermissionSet(extensions::APIPermissionSet(), + extensions::ManifestPermissionSet(), new_hosts, + extensions::URLPatternSet())); + + if (update_origin_whitelist) { + UpdateOriginPermissions( + extension->url(), + old_effective, + extension->permissions_data()->GetEffectiveHostPermissions()); + } +} + +void Dispatcher::OnClearTabSpecificPermissions( + const std::vector<std::string>& extension_ids, + bool update_origin_whitelist, + int tab_id) { + for (const std::string& id : extension_ids) { + const Extension* extension = RendererExtensionRegistry::Get()->GetByID(id); + if (extension) { + URLPatternSet old_effective = + extension->permissions_data()->GetEffectiveHostPermissions(); + extension->permissions_data()->ClearTabSpecificPermissions(tab_id); + if (update_origin_whitelist) { + UpdateOriginPermissions( + extension->url(), + old_effective, + extension->permissions_data()->GetEffectiveHostPermissions()); + } + } + } +} + +void Dispatcher::OnUsingWebRequestAPI(bool webrequest_used) { + webrequest_used_ = webrequest_used; +} + +void Dispatcher::OnUserScriptsUpdated(const std::set<HostID>& changed_hosts, + const std::vector<UserScript*>& scripts) { + UpdateActiveExtensions(); +} + +void Dispatcher::UpdateActiveExtensions() { + std::set<std::string> active_extensions = active_extension_ids_; + user_script_set_manager_->GetAllActiveExtensionIds(&active_extensions); + delegate_->OnActiveExtensionsUpdated(active_extensions); +} + +void Dispatcher::InitOriginPermissions(const Extension* extension) { + delegate_->InitOriginPermissions(extension, + IsExtensionActive(extension->id())); + UpdateOriginPermissions( + extension->url(), + URLPatternSet(), // No old permissions. + extension->permissions_data()->GetEffectiveHostPermissions()); +} + +void Dispatcher::UpdateOriginPermissions(const GURL& extension_url, + const URLPatternSet& old_patterns, + const URLPatternSet& new_patterns) { + static const char* kSchemes[] = { + url::kHttpScheme, + url::kHttpsScheme, + url::kFileScheme, + content::kChromeUIScheme, + url::kFtpScheme, +#if defined(OS_CHROMEOS) + content::kExternalFileScheme, +#endif + extensions::kExtensionScheme, + }; + for (size_t i = 0; i < arraysize(kSchemes); ++i) { + const char* scheme = kSchemes[i]; + // Remove all old patterns... + for (URLPatternSet::const_iterator pattern = old_patterns.begin(); + pattern != old_patterns.end(); ++pattern) { + if (pattern->MatchesScheme(scheme)) { + WebSecurityPolicy::removeOriginAccessWhitelistEntry( + extension_url, + WebString::fromUTF8(scheme), + WebString::fromUTF8(pattern->host()), + pattern->match_subdomains()); + } + } + // ...And add the new ones. + for (URLPatternSet::const_iterator pattern = new_patterns.begin(); + pattern != new_patterns.end(); ++pattern) { + if (pattern->MatchesScheme(scheme)) { + WebSecurityPolicy::addOriginAccessWhitelistEntry( + extension_url, + WebString::fromUTF8(scheme), + WebString::fromUTF8(pattern->host()), + pattern->match_subdomains()); + } + } + } +} + +void Dispatcher::EnableCustomElementWhiteList() { + blink::WebCustomElement::addEmbedderCustomElementName("appview"); + blink::WebCustomElement::addEmbedderCustomElementName("appviewbrowserplugin"); + blink::WebCustomElement::addEmbedderCustomElementName("extensionoptions"); + blink::WebCustomElement::addEmbedderCustomElementName( + "extensionoptionsbrowserplugin"); + blink::WebCustomElement::addEmbedderCustomElementName("extensionview"); + blink::WebCustomElement::addEmbedderCustomElementName( + "extensionviewbrowserplugin"); + 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))); +} + +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::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())) + 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 + // 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, + scoped_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) { + RegisterNativeHandlers(module_system, + context, + this, + request_sender_.get(), + v8_schema_registry_.get()); + 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( + 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()) { + const ContentCapabilitiesInfo& info = + ContentCapabilitiesInfo::Get(extension.get()); + if (info.url_patterns.MatchesURL(context->url())) { + APIPermissionSet new_permissions; + APIPermissionSet::Union(permissions, info.permissions, &new_permissions); + permissions = new_permissions; + } + } + context->set_content_capabilities(permissions); +} + +void Dispatcher::PopulateSourceMap() { + const std::vector<std::pair<std::string, int> > resources = GetJsResources(); + for (std::vector<std::pair<std::string, int> >::const_iterator resource = + resources.begin(); + resource != resources.end(); + ++resource) { + source_map_.RegisterSource(resource->first, resource->second); + } + delegate_->PopulateSourceMap(&source_map_); +} + +bool Dispatcher::IsWithinPlatformApp() { + for (std::set<std::string>::iterator iter = active_extension_ids_.begin(); + iter != active_extension_ids_.end(); + ++iter) { + const Extension* extension = + RendererExtensionRegistry::Get()->GetByID(*iter); + if (extension && extension->is_platform_app()) + return true; + } + return false; +} + +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; +} + +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(); + + // Only set if |context| is capable of running guests in OOPIF. Used to + // require additional module overrides. + bool guest_view_required = false; + + // Require AppView. + if (context->GetAvailability("appViewEmbedderInternal").is_available()) { + module_system->Require("appView"); + } + + // Require ExtensionOptions. + if (context->GetAvailability("extensionOptionsInternal").is_available()) { + module_system->Require("extensionOptions"); + module_system->Require("extensionOptionsAttributes"); + + guest_view_required = true; + } + + // Require ExtensionView. + if (context->GetAvailability("extensionViewInternal").is_available()) { + module_system->Require("extensionView"); + module_system->Require("extensionViewApiMethods"); + module_system->Require("extensionViewAttributes"); + } + + // Require WebView. + if (context->GetAvailability("webViewInternal").is_available()) { + module_system->Require("webView"); + module_system->Require("webViewApiMethods"); + module_system->Require("webViewAttributes"); + if (context->GetAvailability("webViewExperimentalInternal") + .is_available()) { + module_system->Require("webViewExperimental"); + } + + guest_view_required = true; + } + + if (guest_view_required && + content::BrowserPluginGuestMode::UseCrossProcessFramesForGuests()) { + module_system->Require("guestViewIframe"); + module_system->Require("guestViewIframeContainer"); + } + + // 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 |