1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
// Copyright (c) 2009 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 "chrome/renderer/webworker_base.h"
#include "chrome/common/render_messages.h"
#include "chrome/common/render_messages_params.h"
#include "chrome/common/webmessageportchannel_impl.h"
#include "chrome/common/worker_messages.h"
#include "content/common/child_thread.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebWorkerClient.h"
using WebKit::WebMessagePortChannel;
using WebKit::WebMessagePortChannelArray;
using WebKit::WebString;
using WebKit::WebURL;
using WebKit::WebWorkerClient;
WebWorkerBase::WebWorkerBase(
ChildThread* child_thread,
unsigned long long document_id,
int route_id,
int render_view_route_id,
int parent_appcache_host_id)
: route_id_(route_id),
render_view_route_id_(render_view_route_id),
child_thread_(child_thread),
document_id_(document_id),
parent_appcache_host_id_(parent_appcache_host_id) {
if (route_id_ != MSG_ROUTING_NONE)
child_thread_->AddRoute(route_id_, this);
}
WebWorkerBase::~WebWorkerBase() {
Disconnect();
// Free up any unsent queued messages.
for (size_t i = 0; i < queued_messages_.size(); ++i)
delete queued_messages_[i];
}
void WebWorkerBase::Disconnect() {
if (route_id_ == MSG_ROUTING_NONE)
return;
// So the messages from WorkerContext (like WorkerContextDestroyed) do not
// come after nobody is listening. Since Worker and WorkerContext can
// terminate independently, already sent messages may still be in the pipe.
child_thread_->RemoveRoute(route_id_);
route_id_ = MSG_ROUTING_NONE;
}
void WebWorkerBase::CreateWorkerContext(const GURL& script_url,
bool is_shared,
const string16& name,
const string16& user_agent,
const string16& source_code,
int pending_route_id,
int64 script_resource_appcache_id) {
DCHECK(route_id_ == MSG_ROUTING_NONE);
ViewHostMsg_CreateWorker_Params params;
params.url = script_url;
params.is_shared = is_shared;
params.name = name;
params.document_id = document_id_;
params.render_view_route_id = render_view_route_id_;
params.route_id = pending_route_id;
params.parent_appcache_host_id = parent_appcache_host_id_;
params.script_resource_appcache_id = script_resource_appcache_id;
IPC::Message* create_message = new ViewHostMsg_CreateWorker(
params, &route_id_);
child_thread_->Send(create_message);
if (route_id_ == MSG_ROUTING_NONE)
return;
child_thread_->AddRoute(route_id_, this);
// We make sure that the start message is the first, since postMessage or
// connect might have already been called.
queued_messages_.insert(queued_messages_.begin(),
new WorkerMsg_StartWorkerContext(
route_id_, script_url, user_agent, source_code));
}
bool WebWorkerBase::IsStarted() {
// Worker is started if we have a route ID and there are no queued messages
// (meaning we've sent the WorkerMsg_StartWorkerContext already).
return (route_id_ != MSG_ROUTING_NONE && queued_messages_.empty());
}
bool WebWorkerBase::Send(IPC::Message* message) {
// It's possible that messages will be sent before the worker is created, in
// which case route_id_ will be none. Or the worker object can be interacted
// with before the browser process told us that it started, in which case we
// also want to queue the message.
if (!IsStarted()) {
queued_messages_.push_back(message);
return true;
}
// For now we proxy all messages to the worker process through the browser.
// Revisit if we find this slow.
// TODO(jabdelmalek): handle sync messages if we need them.
IPC::Message* wrapped_msg = new ViewHostMsg_ForwardToWorker(*message);
delete message;
return child_thread_->Send(wrapped_msg);
}
void WebWorkerBase::SendQueuedMessages() {
DCHECK(queued_messages_.size());
std::vector<IPC::Message*> queued_messages = queued_messages_;
queued_messages_.clear();
for (size_t i = 0; i < queued_messages.size(); ++i) {
queued_messages[i]->set_routing_id(route_id_);
Send(queued_messages[i]);
}
}
|
