| // 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 "content/renderer/shared_worker/embedded_shared_worker_stub.h" |
| |
| #include <stdint.h> |
| #include <utility> |
| |
| #include "base/threading/thread_task_runner_handle.h" |
| #include "content/child/appcache/appcache_dispatcher.h" |
| #include "content/child/appcache/web_application_cache_host_impl.h" |
| #include "content/child/request_extra_data.h" |
| #include "content/child/scoped_child_process_reference.h" |
| #include "content/child/service_worker/service_worker_handle_reference.h" |
| #include "content/child/service_worker/service_worker_network_provider.h" |
| #include "content/child/service_worker/service_worker_provider_context.h" |
| #include "content/child/shared_worker_devtools_agent.h" |
| #include "content/child/webmessageportchannel_impl.h" |
| #include "content/common/worker_messages.h" |
| #include "content/renderer/render_thread_impl.h" |
| #include "content/renderer/shared_worker/embedded_shared_worker_content_settings_client_proxy.h" |
| #include "ipc/ipc_message_macros.h" |
| #include "third_party/WebKit/public/platform/URLConversion.h" |
| #include "third_party/WebKit/public/platform/WebSecurityOrigin.h" |
| #include "third_party/WebKit/public/web/WebDataSource.h" |
| #include "third_party/WebKit/public/web/WebSharedWorker.h" |
| #include "third_party/WebKit/public/web/WebSharedWorkerClient.h" |
| #include "third_party/WebKit/public/web/modules/serviceworker/WebServiceWorkerNetworkProvider.h" |
| |
| namespace content { |
| |
| namespace { |
| |
| class SharedWorkerWebApplicationCacheHostImpl |
| : public WebApplicationCacheHostImpl { |
| public: |
| SharedWorkerWebApplicationCacheHostImpl( |
| blink::WebApplicationCacheHostClient* client) |
| : WebApplicationCacheHostImpl(client, |
| RenderThreadImpl::current() |
| ->appcache_dispatcher() |
| ->backend_proxy()) {} |
| |
| // Main resource loading is different for workers. The main resource is |
| // loaded by the worker using WorkerScriptLoader. |
| // These overrides are stubbed out. |
| void willStartMainResourceRequest( |
| blink::WebURLRequest&, |
| const blink::WebApplicationCacheHost*) override {} |
| void didReceiveResponseForMainResource( |
| const blink::WebURLResponse&) override {} |
| void didReceiveDataForMainResource(const char* data, unsigned len) override {} |
| void didFinishLoadingMainResource(bool success) override {} |
| |
| // Cache selection is also different for workers. We know at construction |
| // time what cache to select and do so then. |
| // These overrides are stubbed out. |
| void selectCacheWithoutManifest() override {} |
| bool selectCacheWithManifest(const blink::WebURL& manifestURL) override { |
| return true; |
| } |
| }; |
| |
| // We store an instance of this class in the "extra data" of the WebDataSource |
| // and attach a ServiceWorkerNetworkProvider to it as base::UserData. |
| // (see createServiceWorkerNetworkProvider). |
| class DataSourceExtraData |
| : public blink::WebDataSource::ExtraData, |
| public base::SupportsUserData { |
| public: |
| DataSourceExtraData() {} |
| ~DataSourceExtraData() override {} |
| }; |
| |
| // Called on the main thread only and blink owns it. |
| class WebServiceWorkerNetworkProviderImpl |
| : public blink::WebServiceWorkerNetworkProvider { |
| public: |
| // Blink calls this method for each request starting with the main script, |
| // we tag them with the provider id. |
| void willSendRequest(blink::WebDataSource* data_source, |
| blink::WebURLRequest& request) override { |
| ServiceWorkerNetworkProvider* provider = |
| GetNetworkProviderFromDataSource(data_source); |
| std::unique_ptr<RequestExtraData> extra_data(new RequestExtraData); |
| extra_data->set_service_worker_provider_id(provider->provider_id()); |
| request.setExtraData(extra_data.release()); |
| // Explicitly set the SkipServiceWorker flag for subresources here if the |
| // renderer process hasn't received SetControllerServiceWorker message. |
| if (request.getRequestContext() != |
| blink::WebURLRequest::RequestContextSharedWorker && |
| !provider->IsControlledByServiceWorker()) { |
| request.setSkipServiceWorker(true); |
| } |
| } |
| |
| bool isControlledByServiceWorker(blink::WebDataSource& data_source) override { |
| ServiceWorkerNetworkProvider* provider = |
| GetNetworkProviderFromDataSource(&data_source); |
| return provider->IsControlledByServiceWorker(); |
| } |
| |
| int64_t serviceWorkerID(blink::WebDataSource& data_source) override { |
| ServiceWorkerNetworkProvider* provider = |
| GetNetworkProviderFromDataSource(&data_source); |
| if (provider->context()->controller()) |
| return provider->context()->controller()->version_id(); |
| return kInvalidServiceWorkerVersionId; |
| } |
| |
| private: |
| ServiceWorkerNetworkProvider* GetNetworkProviderFromDataSource( |
| const blink::WebDataSource* data_source) { |
| return ServiceWorkerNetworkProvider::FromDocumentState( |
| static_cast<DataSourceExtraData*>(data_source->getExtraData())); |
| } |
| }; |
| |
| } // namespace |
| |
| EmbeddedSharedWorkerStub::EmbeddedSharedWorkerStub( |
| const GURL& url, |
| const base::string16& name, |
| const base::string16& content_security_policy, |
| blink::WebContentSecurityPolicyType security_policy_type, |
| blink::WebAddressSpace creation_address_space, |
| bool pause_on_start, |
| int route_id) |
| : route_id_(route_id), name_(name), url_(url) { |
| RenderThreadImpl::current()->AddEmbeddedWorkerRoute(route_id_, this); |
| impl_ = blink::WebSharedWorker::create(this); |
| if (pause_on_start) { |
| // Pause worker context when it starts and wait until either DevTools client |
| // is attached or explicit resume notification is received. |
| impl_->pauseWorkerContextOnStart(); |
| } |
| worker_devtools_agent_.reset( |
| new SharedWorkerDevToolsAgent(route_id, impl_)); |
| impl_->startWorkerContext(url, name_, content_security_policy, |
| security_policy_type, creation_address_space); |
| } |
| |
| EmbeddedSharedWorkerStub::~EmbeddedSharedWorkerStub() { |
| RenderThreadImpl::current()->RemoveEmbeddedWorkerRoute(route_id_); |
| DCHECK(!impl_); |
| } |
| |
| bool EmbeddedSharedWorkerStub::OnMessageReceived( |
| const IPC::Message& message) { |
| if (worker_devtools_agent_->OnMessageReceived(message)) |
| return true; |
| bool handled = true; |
| IPC_BEGIN_MESSAGE_MAP(EmbeddedSharedWorkerStub, message) |
| IPC_MESSAGE_HANDLER(WorkerMsg_TerminateWorkerContext, |
| OnTerminateWorkerContext) |
| IPC_MESSAGE_HANDLER(WorkerMsg_Connect, OnConnect) |
| IPC_MESSAGE_UNHANDLED(handled = false) |
| IPC_END_MESSAGE_MAP() |
| return handled; |
| } |
| |
| void EmbeddedSharedWorkerStub::OnChannelError() { |
| OnTerminateWorkerContext(); |
| } |
| |
| void EmbeddedSharedWorkerStub::workerReadyForInspection() { |
| Send(new WorkerHostMsg_WorkerReadyForInspection(route_id_)); |
| } |
| |
| void EmbeddedSharedWorkerStub::workerScriptLoaded() { |
| Send(new WorkerHostMsg_WorkerScriptLoaded(route_id_)); |
| running_ = true; |
| // Process any pending connections. |
| for (PendingChannelList::const_iterator iter = pending_channels_.begin(); |
| iter != pending_channels_.end(); |
| ++iter) { |
| ConnectToChannel(*iter); |
| } |
| pending_channels_.clear(); |
| } |
| |
| void EmbeddedSharedWorkerStub::workerScriptLoadFailed() { |
| Send(new WorkerHostMsg_WorkerScriptLoadFailed(route_id_)); |
| for (PendingChannelList::const_iterator iter = pending_channels_.begin(); |
| iter != pending_channels_.end(); |
| ++iter) { |
| blink::WebMessagePortChannel* channel = *iter; |
| channel->destroy(); |
| } |
| pending_channels_.clear(); |
| Shutdown(); |
| } |
| |
| void EmbeddedSharedWorkerStub::workerContextClosed() { |
| Send(new WorkerHostMsg_WorkerContextClosed(route_id_)); |
| } |
| |
| void EmbeddedSharedWorkerStub::workerContextDestroyed() { |
| Send(new WorkerHostMsg_WorkerContextDestroyed(route_id_)); |
| Shutdown(); |
| } |
| |
| void EmbeddedSharedWorkerStub::selectAppCacheID(long long app_cache_id) { |
| if (app_cache_host_) { |
| // app_cache_host_ could become stale as it's owned by blink's |
| // DocumentLoader. This method is assumed to be called while it's valid. |
| app_cache_host_->backend()->SelectCacheForSharedWorker( |
| app_cache_host_->host_id(), app_cache_id); |
| } |
| } |
| |
| blink::WebNotificationPresenter* |
| EmbeddedSharedWorkerStub::notificationPresenter() { |
| // TODO(horo): delete this method if we have no plan to implement this. |
| NOTREACHED(); |
| return NULL; |
| } |
| |
| blink::WebApplicationCacheHost* |
| EmbeddedSharedWorkerStub::createApplicationCacheHost( |
| blink::WebApplicationCacheHostClient* client) { |
| app_cache_host_ = new SharedWorkerWebApplicationCacheHostImpl(client); |
| return app_cache_host_; |
| } |
| |
| blink::WebWorkerContentSettingsClientProxy* |
| EmbeddedSharedWorkerStub::createWorkerContentSettingsClientProxy( |
| const blink::WebSecurityOrigin& origin) { |
| return new EmbeddedSharedWorkerContentSettingsClientProxy( |
| blink::WebStringToGURL(origin.toString()), |
| origin.isUnique(), |
| route_id_, |
| ChildThreadImpl::current()->thread_safe_sender()); |
| } |
| |
| blink::WebServiceWorkerNetworkProvider* |
| EmbeddedSharedWorkerStub::createServiceWorkerNetworkProvider( |
| blink::WebDataSource* data_source) { |
| // Create a content::ServiceWorkerNetworkProvider for this data source so |
| // we can observe its requests. |
| std::unique_ptr<ServiceWorkerNetworkProvider> provider( |
| new ServiceWorkerNetworkProvider( |
| route_id_, SERVICE_WORKER_PROVIDER_FOR_SHARED_WORKER, |
| true /* is_parent_frame_secure */)); |
| |
| // The provider is kept around for the lifetime of the DataSource |
| // and ownership is transferred to the DataSource. |
| DataSourceExtraData* extra_data = new DataSourceExtraData(); |
| data_source->setExtraData(extra_data); |
| ServiceWorkerNetworkProvider::AttachToDocumentState(extra_data, |
| std::move(provider)); |
| |
| // Blink is responsible for deleting the returned object. |
| return new WebServiceWorkerNetworkProviderImpl(); |
| } |
| |
| void EmbeddedSharedWorkerStub::sendDevToolsMessage( |
| int session_id, |
| int call_id, |
| const blink::WebString& message, |
| const blink::WebString& state) { |
| worker_devtools_agent_->SendDevToolsMessage( |
| session_id, call_id, message, state); |
| } |
| |
| void EmbeddedSharedWorkerStub::Shutdown() { |
| // WebSharedWorker must be already deleted in the blink side |
| // when this is called. |
| impl_ = nullptr; |
| delete this; |
| } |
| |
| bool EmbeddedSharedWorkerStub::Send(IPC::Message* message) { |
| return RenderThreadImpl::current()->Send(message); |
| } |
| |
| void EmbeddedSharedWorkerStub::ConnectToChannel( |
| WebMessagePortChannelImpl* channel) { |
| impl_->connect(channel); |
| Send( |
| new WorkerHostMsg_WorkerConnected(channel->message_port_id(), route_id_)); |
| } |
| |
| void EmbeddedSharedWorkerStub::OnConnect(int port, |
| int routing_id) { |
| WebMessagePortChannelImpl* channel = new WebMessagePortChannelImpl( |
| routing_id, port, base::ThreadTaskRunnerHandle::Get().get()); |
| if (running_) { |
| ConnectToChannel(channel); |
| } else { |
| // If two documents try to load a SharedWorker at the same time, the |
| // WorkerMsg_Connect for one of the documents can come in before the |
| // worker is started. Just queue up the connect and deliver it once the |
| // worker starts. |
| pending_channels_.push_back(channel); |
| } |
| } |
| |
| void EmbeddedSharedWorkerStub::OnTerminateWorkerContext() { |
| // After this we wouldn't get any IPC for this stub. |
| running_ = false; |
| impl_->terminateWorkerContext(); |
| } |
| |
| } // namespace content |