Index: content/renderer/shared_worker/embedded_shared_worker_stub.cc |
diff --git a/content/worker/websharedworker_stub.cc b/content/renderer/shared_worker/embedded_shared_worker_stub.cc |
similarity index 39% |
copy from content/worker/websharedworker_stub.cc |
copy to content/renderer/shared_worker/embedded_shared_worker_stub.cc |
index 19d3ec988cdac9b33b614524cc339de493b09f56..d8f5e701a73e497af8270551822bb18d11fdfd8e 100644 |
--- a/content/worker/websharedworker_stub.cc |
+++ b/content/renderer/shared_worker/embedded_shared_worker_stub.cc |
@@ -1,71 +1,52 @@ |
-// Copyright (c) 2012 The Chromium Authors. All rights reserved. |
+// Copyright 2013 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/worker/websharedworker_stub.h" |
+#include "content/renderer/shared_worker/embedded_shared_worker_stub.h" |
-#include "base/compiler_specific.h" |
-#include "content/child/child_process.h" |
+#include "base/message_loop/message_loop_proxy.h" |
#include "content/child/child_thread.h" |
-#include "content/child/fileapi/file_system_dispatcher.h" |
+#include "content/child/scoped_child_process_reference.h" |
+#include "content/child/shared_worker_devtools_agent.h" |
+#include "content/child/thread_safe_sender.h" |
#include "content/child/webmessageportchannel_impl.h" |
+#include "content/child/worker_thread_task_runner.h" |
kinuko
2014/02/13 09:06:48
Not necessary?
horo
2014/02/13 09:38:28
Done.
|
#include "content/common/worker_messages.h" |
-#include "content/worker/shared_worker_devtools_agent.h" |
-#include "content/worker/worker_thread.h" |
+#include "content/renderer/render_thread_impl.h" |
+#include "ipc/ipc_message_macros.h" |
#include "third_party/WebKit/public/web/WebSharedWorker.h" |
-#include "third_party/WebKit/public/platform/WebString.h" |
-#include "third_party/WebKit/public/platform/WebURL.h" |
+#include "third_party/WebKit/public/web/WebSharedWorkerClient.h" |
namespace content { |
-WebSharedWorkerStub::WebSharedWorkerStub( |
+EmbeddedSharedWorkerStub::EmbeddedSharedWorkerStub( |
const GURL& url, |
const base::string16& name, |
const base::string16& content_security_policy, |
blink::WebContentSecurityPolicyType security_policy_type, |
int route_id) |
: route_id_(route_id), |
- client_(route_id, this), |
- running_(false), |
+ name_(name), |
+ runing_(false), |
url_(url) { |
- |
- WorkerThread* worker_thread = WorkerThread::current(); |
- DCHECK(worker_thread); |
- worker_thread->AddWorkerStub(this); |
- // Start processing incoming IPCs for this worker. |
- worker_thread->AddRoute(route_id_, this); |
- |
- // TODO(atwilson): Add support for NaCl when they support MessagePorts. |
- impl_ = blink::WebSharedWorker::create(client()); |
- worker_devtools_agent_.reset(new SharedWorkerDevToolsAgent(route_id, impl_)); |
- client()->set_devtools_agent(worker_devtools_agent_.get()); |
- impl_->startWorkerContext(url_, name, |
+ RenderThreadImpl::current()->AddRoute(route_id_, this); |
+ impl_ = blink::WebSharedWorker::create(this); |
+ worker_devtools_agent_.reset( |
+ new SharedWorkerDevToolsAgent(route_id, impl_)); |
+ impl_->startWorkerContext(url, name_, |
content_security_policy, security_policy_type); |
} |
-WebSharedWorkerStub::~WebSharedWorkerStub() { |
- impl_->clientDestroyed(); |
- WorkerThread* worker_thread = WorkerThread::current(); |
- DCHECK(worker_thread); |
- worker_thread->RemoveWorkerStub(this); |
- worker_thread->RemoveRoute(route_id_); |
+EmbeddedSharedWorkerStub::~EmbeddedSharedWorkerStub() { |
+ RenderThreadImpl::current()->RemoveRoute(route_id_); |
} |
-void WebSharedWorkerStub::Shutdown() { |
- // The worker has exited - free ourselves and the client. |
- delete this; |
-} |
- |
-void WebSharedWorkerStub::EnsureWorkerContextTerminates() { |
- client_.EnsureWorkerContextTerminates(); |
-} |
- |
-bool WebSharedWorkerStub::OnMessageReceived(const IPC::Message& message) { |
+bool EmbeddedSharedWorkerStub::OnMessageReceived( |
+ const IPC::Message& message) { |
if (worker_devtools_agent_->OnMessageReceived(message)) |
return true; |
- |
bool handled = true; |
- IPC_BEGIN_MESSAGE_MAP(WebSharedWorkerStub, message) |
+ IPC_BEGIN_MESSAGE_MAP(EmbeddedSharedWorkerStub, message) |
IPC_MESSAGE_HANDLER(WorkerMsg_TerminateWorkerContext, |
OnTerminateWorkerContext) |
IPC_MESSAGE_HANDLER(WorkerMsg_Connect, OnConnect) |
@@ -74,56 +55,26 @@ bool WebSharedWorkerStub::OnMessageReceived(const IPC::Message& message) { |
return handled; |
} |
-void WebSharedWorkerStub::OnChannelError() { |
- OnTerminateWorkerContext(); |
-} |
- |
-const GURL& WebSharedWorkerStub::url() { |
- return url_; |
+void EmbeddedSharedWorkerStub::OnChannelError() { |
+ OnTerminateWorkerContext(); |
} |
-void WebSharedWorkerStub::OnConnect(int sent_message_port_id, int routing_id) { |
- WebMessagePortChannelImpl* channel = |
- new WebMessagePortChannelImpl(routing_id, |
- sent_message_port_id, |
- base::MessageLoopProxy::current().get()); |
- if (running_) { |
- impl_->connect(channel); |
- WorkerThread::current()->Send( |
- new WorkerHostMsg_WorkerConnected(channel->message_port_id(), |
- route_id_)); |
- } 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 WebSharedWorkerStub::OnTerminateWorkerContext() { |
- impl_->terminateWorkerContext(); |
- |
- // Call the client to make sure context exits. |
- EnsureWorkerContextTerminates(); |
- running_ = false; |
-} |
- |
-void WebSharedWorkerStub::WorkerScriptLoaded() { |
- running_ = true; |
+void EmbeddedSharedWorkerStub::workerScriptLoaded() { |
+ Send(new WorkerHostMsg_WorkerScriptLoaded(route_id_)); |
+ runing_ = true; |
// Process any pending connections. |
for (PendingChannelList::const_iterator iter = pending_channels_.begin(); |
iter != pending_channels_.end(); |
++iter) { |
impl_->connect(*iter); |
- WorkerThread::current()->Send( |
- new WorkerHostMsg_WorkerConnected((*iter)->message_port_id(), |
- route_id_)); |
+ Send(new WorkerHostMsg_WorkerConnected((*iter)->message_port_id(), |
+ route_id_)); |
} |
pending_channels_.clear(); |
} |
-void WebSharedWorkerStub::WorkerScriptLoadFailed() { |
+void EmbeddedSharedWorkerStub::workerScriptLoadFailed() { |
+ Send(new WorkerHostMsg_WorkerScriptLoadFailed(route_id_)); |
for (PendingChannelList::const_iterator iter = pending_channels_.begin(); |
iter != pending_channels_.end(); |
++iter) { |
@@ -134,4 +85,78 @@ void WebSharedWorkerStub::WorkerScriptLoadFailed() { |
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) { |
+ // TODO(horo): implement this. |
+} |
+ |
+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*) { |
+ // TODO(horo): implement this. |
+ return NULL; |
+} |
+ |
+blink::WebWorkerPermissionClientProxy* |
+ EmbeddedSharedWorkerStub::createWorkerPermissionClientProxy( |
+ const blink::WebSecurityOrigin& origin) { |
+ // TODO(horo): implement this. |
+ return NULL; |
+} |
+ |
+void EmbeddedSharedWorkerStub::dispatchDevToolsMessage( |
+ const blink::WebString& message) { |
+ worker_devtools_agent_->SendDevToolsMessage(message); |
+} |
+ |
+void EmbeddedSharedWorkerStub::saveDevToolsAgentState( |
+ const blink::WebString& state) { |
+ worker_devtools_agent_->SaveDevToolsAgentState(state); |
+} |
+ |
+void EmbeddedSharedWorkerStub::Shutdown() { |
+ delete this; |
+} |
+ |
+bool EmbeddedSharedWorkerStub::Send(IPC::Message* message) { |
+ return RenderThreadImpl::current()->Send(message); |
+} |
+ |
+void EmbeddedSharedWorkerStub::OnConnect(int sent_message_port_id, |
+ int routing_id) { |
+ WebMessagePortChannelImpl* channel = |
+ new WebMessagePortChannelImpl(routing_id, |
+ sent_message_port_id, |
+ base::MessageLoopProxy::current().get()); |
+ if (runing_) { |
+ impl_->connect(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() { |
+ runing_ = false; |
+ impl_->terminateWorkerContext(); |
+} |
+ |
} // namespace content |