#include "content/child/child_process.h"
#include "content/child/child_thread.h"
#include "content/child/fileapi/file_system_dispatcher.h"
+#include "content/child/shared_worker_devtools_agent.h"
#include "content/child/webmessageportchannel_impl.h"
#include "content/common/worker_messages.h"
-#include "content/worker/shared_worker_devtools_agent.h"
#include "content/worker/worker_thread.h"
#include "third_party/WebKit/public/web/WebSharedWorker.h"
#include "third_party/WebKit/public/platform/WebString.h"
const base::string16& name,
const base::string16& content_security_policy,
blink::WebContentSecurityPolicyType security_policy_type,
- int route_id,
- const WorkerAppCacheInitInfo& appcache_init_info)
+ int route_id)
: route_id_(route_id),
- appcache_init_info_(appcache_init_info),
client_(route_id, this),
- name_(name),
- started_(false),
- worker_script_loaded_(false) {
+ running_(false),
+ url_(url) {
WorkerThread* worker_thread = WorkerThread::current();
DCHECK(worker_thread);
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,
+ content_security_policy, security_policy_type);
}
WebSharedWorkerStub::~WebSharedWorkerStub() {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(WebSharedWorkerStub, message)
- IPC_MESSAGE_HANDLER(WorkerMsg_StartWorkerContext, OnStartWorkerContext)
IPC_MESSAGE_HANDLER(WorkerMsg_TerminateWorkerContext,
OnTerminateWorkerContext)
IPC_MESSAGE_HANDLER(WorkerMsg_Connect, OnConnect)
return url_;
}
-void WebSharedWorkerStub::OnStartWorkerContext(
- const GURL& url, const base::string16& user_agent,
- const base::string16& source_code,
- const base::string16& content_security_policy,
- blink::WebContentSecurityPolicyType policy_type) {
- // Ignore multiple attempts to start this worker (can happen if two pages
- // try to start it simultaneously).
- if (started_)
- return;
-
- impl_->startWorkerContext(url, name_, user_agent, source_code,
- content_security_policy, policy_type, 0);
- started_ = true;
- url_ = url;
-}
-
void WebSharedWorkerStub::OnConnect(int sent_message_port_id, int routing_id) {
- blink::WebMessagePortChannel* channel =
+ WebMessagePortChannelImpl* channel =
new WebMessagePortChannelImpl(routing_id,
sent_message_port_id,
base::MessageLoopProxy::current().get());
- if (started_ && worker_script_loaded_) {
+ 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
}
void WebSharedWorkerStub::OnTerminateWorkerContext() {
- impl_->terminateWorkerContext();
-
+ running_ = false;
// Call the client to make sure context exits.
EnsureWorkerContextTerminates();
- started_ = false;
+ // This may call "delete this" via WorkerScriptLoadFailed and Shutdown.
+ impl_->terminateWorkerContext();
}
void WebSharedWorkerStub::WorkerScriptLoaded() {
- worker_script_loaded_ = true;
+ running_ = 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_));
}
pending_channels_.clear();
}
void WebSharedWorkerStub::WorkerScriptLoadFailed() {
- // FIXME(horo): Implement this.
+ for (PendingChannelList::const_iterator iter = pending_channels_.begin();
+ iter != pending_channels_.end();
+ ++iter) {
+ blink::WebMessagePortChannel* channel = *iter;
+ channel->destroy();
+ }
+ pending_channels_.clear();
+ Shutdown();
}
} // namespace content