OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/shared_worker/shared_worker_service_impl.h" | 5 #include "content/browser/shared_worker/shared_worker_service_impl.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <map> | 9 #include <map> |
10 #include <memory> | 10 #include <memory> |
11 #include <set> | 11 #include <set> |
12 #include <string> | 12 #include <string> |
13 #include <tuple> | 13 #include <tuple> |
14 | 14 |
15 #include "base/atomic_sequence_num.h" | 15 #include "base/atomic_sequence_num.h" |
16 #include "base/macros.h" | 16 #include "base/macros.h" |
17 #include "base/memory/ptr_util.h" | 17 #include "base/memory/ptr_util.h" |
18 #include "base/strings/string16.h" | 18 #include "base/strings/string16.h" |
19 #include "base/strings/utf_string_conversions.h" | 19 #include "base/strings/utf_string_conversions.h" |
20 #include "base/synchronization/lock.h" | 20 #include "base/synchronization/lock.h" |
21 #include "content/browser/message_port_message_filter.h" | 21 #include "base/synchronization/waitable_event.h" |
22 #include "content/browser/shared_worker/shared_worker_message_filter.h" | 22 #include "content/browser/shared_worker/shared_worker_message_filter.h" |
23 #include "content/browser/shared_worker/worker_storage_partition.h" | 23 #include "content/browser/shared_worker/worker_storage_partition.h" |
24 #include "content/common/message_port_messages.h" | |
25 #include "content/common/view_messages.h" | 24 #include "content/common/view_messages.h" |
26 #include "content/common/worker_messages.h" | 25 #include "content/common/worker_messages.h" |
27 #include "content/public/browser/storage_partition.h" | 26 #include "content/public/browser/storage_partition.h" |
28 #include "content/public/test/test_browser_context.h" | 27 #include "content/public/test/test_browser_context.h" |
29 #include "content/public/test/test_browser_thread_bundle.h" | 28 #include "content/public/test/test_browser_thread_bundle.h" |
30 #include "content/public/test/test_utils.h" | 29 #include "content/public/test/test_utils.h" |
31 #include "ipc/ipc_sync_message.h" | 30 #include "ipc/ipc_sync_message.h" |
32 #include "testing/gtest/include/gtest/gtest.h" | 31 #include "testing/gtest/include/gtest/gtest.h" |
33 | 32 |
34 namespace content { | 33 namespace content { |
35 | 34 |
35 typedef std::pair<base::string16, std::vector<MessagePort>> QueuedMessage; | |
kinuko
2017/02/08 09:45:06
nit: using QueuedMessage = ...
darin (slow to review)
2017/02/08 17:09:17
Actually, looks like I can just delete this altoge
| |
36 | |
36 class SharedWorkerServiceImplTest : public testing::Test { | 37 class SharedWorkerServiceImplTest : public testing::Test { |
37 public: | 38 public: |
38 static void RegisterRunningProcessID(int process_id) { | 39 static void RegisterRunningProcessID(int process_id) { |
39 base::AutoLock lock(s_lock_); | 40 base::AutoLock lock(s_lock_); |
40 s_running_process_id_set_.insert(process_id); | 41 s_running_process_id_set_.insert(process_id); |
41 } | 42 } |
42 static void UnregisterRunningProcessID(int process_id) { | 43 static void UnregisterRunningProcessID(int process_id) { |
43 base::AutoLock lock(s_lock_); | 44 base::AutoLock lock(s_lock_); |
44 s_running_process_id_set_.erase(process_id); | 45 s_running_process_id_set_.erase(process_id); |
45 } | 46 } |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
105 std::vector<int> SharedWorkerServiceImplTest::s_worker_dependency_removed_ids_; | 106 std::vector<int> SharedWorkerServiceImplTest::s_worker_dependency_removed_ids_; |
106 base::Lock SharedWorkerServiceImplTest::s_lock_; | 107 base::Lock SharedWorkerServiceImplTest::s_lock_; |
107 std::set<int> SharedWorkerServiceImplTest::s_running_process_id_set_; | 108 std::set<int> SharedWorkerServiceImplTest::s_running_process_id_set_; |
108 | 109 |
109 namespace { | 110 namespace { |
110 | 111 |
111 static const int kProcessIDs[] = {100, 101, 102}; | 112 static const int kProcessIDs[] = {100, 101, 102}; |
112 static const unsigned long long kDocumentIDs[] = {200, 201, 202}; | 113 static const unsigned long long kDocumentIDs[] = {200, 201, 202}; |
113 static const int kRenderFrameRouteIDs[] = {300, 301, 302}; | 114 static const int kRenderFrameRouteIDs[] = {300, 301, 302}; |
114 | 115 |
115 class MockMessagePortMessageFilter : public MessagePortMessageFilter { | 116 void BlockingReadFromMessagePort(MessagePort port, base::string16* message) { |
116 public: | 117 base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL, |
117 MockMessagePortMessageFilter( | 118 base::WaitableEvent::InitialState::NOT_SIGNALED); |
118 const NextRoutingIDCallback& callback, | 119 port.SetCallback( |
119 std::vector<std::unique_ptr<IPC::Message>>* message_queue) | 120 base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event))); |
120 : MessagePortMessageFilter(callback), message_queue_(message_queue) {} | 121 event.Wait(); |
121 | 122 |
122 bool Send(IPC::Message* message) override { | 123 std::vector<MessagePort> should_be_empty; |
123 std::unique_ptr<IPC::Message> owned(message); | 124 EXPECT_TRUE(port.GetMessage(message, &should_be_empty)); |
124 if (!message_queue_) | 125 EXPECT_TRUE(should_be_empty.empty()); |
125 return false; | 126 } |
126 message_queue_->push_back(std::move(owned)); | |
127 return true; | |
128 } | |
129 | |
130 void Close() { | |
131 message_queue_ = nullptr; | |
132 OnChannelClosing(); | |
133 } | |
134 | |
135 private: | |
136 ~MockMessagePortMessageFilter() override {} | |
137 std::vector<std::unique_ptr<IPC::Message>>* message_queue_; | |
138 }; | |
139 | 127 |
140 class MockSharedWorkerMessageFilter : public SharedWorkerMessageFilter { | 128 class MockSharedWorkerMessageFilter : public SharedWorkerMessageFilter { |
141 public: | 129 public: |
142 MockSharedWorkerMessageFilter( | 130 MockSharedWorkerMessageFilter( |
143 int render_process_id, | 131 int render_process_id, |
144 ResourceContext* resource_context, | 132 ResourceContext* resource_context, |
145 const WorkerStoragePartition& partition, | 133 const WorkerStoragePartition& partition, |
146 MessagePortMessageFilter* message_port_filter, | 134 SharedWorkerMessageFilter::NextRoutingIDCallback callback, |
kinuko
2017/02/08 09:45:06
nit: const ref
darin (slow to review)
2017/02/08 17:09:17
Done.
| |
147 std::vector<std::unique_ptr<IPC::Message>>* message_queue) | 135 std::vector<std::unique_ptr<IPC::Message>>* message_queue) |
148 : SharedWorkerMessageFilter(render_process_id, | 136 : SharedWorkerMessageFilter(render_process_id, |
149 resource_context, | 137 resource_context, |
150 partition, | 138 partition, |
151 message_port_filter), | 139 callback), |
152 message_queue_(message_queue) {} | 140 message_queue_(message_queue) {} |
153 | 141 |
154 bool Send(IPC::Message* message) override { | 142 bool Send(IPC::Message* message) override { |
155 std::unique_ptr<IPC::Message> owned(message); | 143 std::unique_ptr<IPC::Message> owned(message); |
156 if (!message_queue_) | 144 if (!message_queue_) |
157 return false; | 145 return false; |
158 message_queue_->push_back(std::move(owned)); | 146 message_queue_->push_back(std::move(owned)); |
159 return true; | 147 return true; |
160 } | 148 } |
161 | 149 |
162 void Close() { | 150 void Close() { |
163 message_queue_ = nullptr; | 151 message_queue_ = nullptr; |
164 OnChannelClosing(); | 152 OnChannelClosing(); |
165 } | 153 } |
166 | 154 |
167 private: | 155 private: |
168 ~MockSharedWorkerMessageFilter() override {} | 156 ~MockSharedWorkerMessageFilter() override {} |
169 std::vector<std::unique_ptr<IPC::Message>>* message_queue_; | 157 std::vector<std::unique_ptr<IPC::Message>>* message_queue_; |
170 }; | 158 }; |
171 | 159 |
172 class MockRendererProcessHost { | 160 class MockRendererProcessHost { |
173 public: | 161 public: |
174 MockRendererProcessHost(int process_id, | 162 MockRendererProcessHost(int process_id, |
175 ResourceContext* resource_context, | 163 ResourceContext* resource_context, |
176 const WorkerStoragePartition& partition) | 164 const WorkerStoragePartition& partition) |
177 : process_id_(process_id), | 165 : process_id_(process_id), |
178 message_filter_(new MockMessagePortMessageFilter( | 166 worker_filter_(new MockSharedWorkerMessageFilter( |
167 process_id, | |
168 resource_context, | |
169 partition, | |
179 base::Bind(&base::AtomicSequenceNumber::GetNext, | 170 base::Bind(&base::AtomicSequenceNumber::GetNext, |
180 base::Unretained(&next_routing_id_)), | 171 base::Unretained(&next_routing_id_)), |
181 &queued_messages_)), | 172 &queued_messages_)) { |
182 worker_filter_(new MockSharedWorkerMessageFilter(process_id, | |
183 resource_context, | |
184 partition, | |
185 message_filter_.get(), | |
186 &queued_messages_)) { | |
187 SharedWorkerServiceImplTest::RegisterRunningProcessID(process_id); | 173 SharedWorkerServiceImplTest::RegisterRunningProcessID(process_id); |
188 } | 174 } |
189 | 175 |
190 ~MockRendererProcessHost() { | 176 ~MockRendererProcessHost() { |
191 SharedWorkerServiceImplTest::UnregisterRunningProcessID(process_id_); | 177 SharedWorkerServiceImplTest::UnregisterRunningProcessID(process_id_); |
192 message_filter_->Close(); | |
193 worker_filter_->Close(); | 178 worker_filter_->Close(); |
194 } | 179 } |
195 | 180 |
196 bool OnMessageReceived(IPC::Message* message) { | 181 bool OnMessageReceived(IPC::Message* message) { |
197 std::unique_ptr<IPC::Message> msg(message); | 182 std::unique_ptr<IPC::Message> msg(message); |
198 const bool ret = message_filter_->OnMessageReceived(*message) || | 183 const bool ret = worker_filter_->OnMessageReceived(*message); |
199 worker_filter_->OnMessageReceived(*message); | |
200 if (message->is_sync()) { | 184 if (message->is_sync()) { |
201 CHECK(!queued_messages_.empty()); | 185 CHECK(!queued_messages_.empty()); |
202 std::unique_ptr<IPC::Message> response_msg( | 186 std::unique_ptr<IPC::Message> response_msg( |
203 queued_messages_.back().release()); | 187 queued_messages_.back().release()); |
204 queued_messages_.pop_back(); | 188 queued_messages_.pop_back(); |
205 IPC::SyncMessage* sync_msg = static_cast<IPC::SyncMessage*>(message); | 189 IPC::SyncMessage* sync_msg = static_cast<IPC::SyncMessage*>(message); |
206 std::unique_ptr<IPC::MessageReplyDeserializer> reply_serializer( | 190 std::unique_ptr<IPC::MessageReplyDeserializer> reply_serializer( |
207 sync_msg->GetReplyDeserializer()); | 191 sync_msg->GetReplyDeserializer()); |
208 bool result = reply_serializer->SerializeOutputParameters(*response_msg); | 192 bool result = reply_serializer->SerializeOutputParameters(*response_msg); |
209 CHECK(result); | 193 CHECK(result); |
(...skipping 11 matching lines...) Expand all Loading... | |
221 } | 205 } |
222 | 206 |
223 void FastShutdownIfPossible() { | 207 void FastShutdownIfPossible() { |
224 SharedWorkerServiceImplTest::UnregisterRunningProcessID(process_id_); | 208 SharedWorkerServiceImplTest::UnregisterRunningProcessID(process_id_); |
225 } | 209 } |
226 | 210 |
227 private: | 211 private: |
228 const int process_id_; | 212 const int process_id_; |
229 std::vector<std::unique_ptr<IPC::Message>> queued_messages_; | 213 std::vector<std::unique_ptr<IPC::Message>> queued_messages_; |
230 base::AtomicSequenceNumber next_routing_id_; | 214 base::AtomicSequenceNumber next_routing_id_; |
231 scoped_refptr<MockMessagePortMessageFilter> message_filter_; | |
232 scoped_refptr<MockSharedWorkerMessageFilter> worker_filter_; | 215 scoped_refptr<MockSharedWorkerMessageFilter> worker_filter_; |
233 }; | 216 }; |
234 | 217 |
235 void CreateMessagePortPair(MockRendererProcessHost* renderer, | |
236 int* route_1, | |
237 int* port_1, | |
238 int* route_2, | |
239 int* port_2) { | |
240 EXPECT_TRUE(renderer->OnMessageReceived( | |
241 new MessagePortHostMsg_CreateMessagePort(route_1, port_1))); | |
242 EXPECT_TRUE(renderer->OnMessageReceived( | |
243 new MessagePortHostMsg_CreateMessagePort(route_2, port_2))); | |
244 EXPECT_TRUE(renderer->OnMessageReceived( | |
245 new MessagePortHostMsg_Entangle(*port_1, *port_2))); | |
246 EXPECT_TRUE(renderer->OnMessageReceived( | |
247 new MessagePortHostMsg_Entangle(*port_2, *port_1))); | |
248 } | |
249 | |
250 void PostCreateWorker(MockRendererProcessHost* renderer, | 218 void PostCreateWorker(MockRendererProcessHost* renderer, |
251 const std::string& url, | 219 const std::string& url, |
252 const std::string& name, | 220 const std::string& name, |
253 unsigned long long document_id, | 221 unsigned long long document_id, |
254 int render_frame_route_id, | 222 int render_frame_route_id, |
255 ViewHostMsg_CreateWorker_Reply* reply) { | 223 ViewHostMsg_CreateWorker_Reply* reply) { |
256 ViewHostMsg_CreateWorker_Params params; | 224 ViewHostMsg_CreateWorker_Params params; |
257 params.url = GURL(url); | 225 params.url = GURL(url); |
258 params.name = base::ASCIIToUTF16(name); | 226 params.name = base::ASCIIToUTF16(name); |
259 params.content_security_policy = base::string16(); | 227 params.content_security_policy = base::string16(); |
260 params.security_policy_type = blink::WebContentSecurityPolicyTypeReport; | 228 params.security_policy_type = blink::WebContentSecurityPolicyTypeReport; |
261 params.document_id = document_id; | 229 params.document_id = document_id; |
262 params.render_frame_route_id = render_frame_route_id; | 230 params.render_frame_route_id = render_frame_route_id; |
263 params.creation_context_type = | 231 params.creation_context_type = |
264 blink::WebSharedWorkerCreationContextTypeSecure; | 232 blink::WebSharedWorkerCreationContextTypeSecure; |
265 EXPECT_TRUE( | 233 EXPECT_TRUE( |
266 renderer->OnMessageReceived(new ViewHostMsg_CreateWorker(params, reply))); | 234 renderer->OnMessageReceived(new ViewHostMsg_CreateWorker(params, reply))); |
267 } | 235 } |
268 | 236 |
269 class MockSharedWorkerConnector { | 237 class MockSharedWorkerConnector { |
270 public: | 238 public: |
271 MockSharedWorkerConnector(MockRendererProcessHost* renderer_host) | 239 MockSharedWorkerConnector(MockRendererProcessHost* renderer_host) |
272 : renderer_host_(renderer_host), | 240 : renderer_host_(renderer_host) {} |
273 temporary_remote_port_route_id_(0), | |
274 remote_port_id_(0), | |
275 local_port_route_id_(0), | |
276 local_port_id_(0) {} | |
277 void Create(const std::string& url, | 241 void Create(const std::string& url, |
278 const std::string& name, | 242 const std::string& name, |
279 unsigned long long document_id, | 243 unsigned long long document_id, |
280 int render_frame_route_id) { | 244 int render_frame_route_id) { |
281 CreateMessagePortPair(renderer_host_, | |
282 &temporary_remote_port_route_id_, | |
283 &remote_port_id_, | |
284 &local_port_route_id_, | |
285 &local_port_id_); | |
286 PostCreateWorker(renderer_host_, url, name, document_id, | 245 PostCreateWorker(renderer_host_, url, name, document_id, |
287 render_frame_route_id, &create_worker_reply_); | 246 render_frame_route_id, &create_worker_reply_); |
288 } | 247 } |
289 void SendQueueMessages() { | |
290 EXPECT_TRUE(renderer_host_->OnMessageReceived( | |
291 new MessagePortHostMsg_QueueMessages(remote_port_id_))); | |
292 } | |
293 void SendPostMessage(const std::string& data) { | |
294 const std::vector<int> empty_ports; | |
295 EXPECT_TRUE( | |
296 renderer_host_->OnMessageReceived(new MessagePortHostMsg_PostMessage( | |
297 local_port_id_, base::ASCIIToUTF16(data), empty_ports))); | |
298 } | |
299 void SendConnect() { | 248 void SendConnect() { |
249 mojo::MessagePipe message_pipe; | |
250 local_port_ = MessagePort(std::move(message_pipe.handle0)); | |
251 | |
300 EXPECT_TRUE( | 252 EXPECT_TRUE( |
301 renderer_host_->OnMessageReceived(new ViewHostMsg_ConnectToWorker( | 253 renderer_host_->OnMessageReceived(new ViewHostMsg_ConnectToWorker( |
302 create_worker_reply_.route_id, remote_port_id_))); | 254 create_worker_reply_.route_id, |
255 MessagePort(std::move(message_pipe.handle1))))); | |
303 } | 256 } |
304 void SendSendQueuedMessages( | 257 MessagePort local_port() { return local_port_; } |
305 const std::vector<QueuedMessage>& queued_messages) { | |
306 EXPECT_TRUE(renderer_host_->OnMessageReceived( | |
307 new MessagePortHostMsg_SendQueuedMessages(remote_port_id_, | |
308 queued_messages))); | |
309 } | |
310 int temporary_remote_port_route_id() { | |
311 return temporary_remote_port_route_id_; | |
312 } | |
313 int remote_port_id() { return remote_port_id_; } | |
314 int local_port_route_id() { return local_port_route_id_; } | |
315 int local_port_id() { return local_port_id_; } | |
316 int route_id() { return create_worker_reply_.route_id; } | 258 int route_id() { return create_worker_reply_.route_id; } |
317 blink::WebWorkerCreationError creation_error() { | 259 blink::WebWorkerCreationError creation_error() { |
318 return create_worker_reply_.error; | 260 return create_worker_reply_.error; |
319 } | 261 } |
320 | |
321 private: | 262 private: |
322 MockRendererProcessHost* renderer_host_; | 263 MockRendererProcessHost* renderer_host_; |
323 int temporary_remote_port_route_id_; | 264 MessagePort local_port_; |
324 int remote_port_id_; | |
325 int local_port_route_id_; | |
326 int local_port_id_; | |
327 ViewHostMsg_CreateWorker_Reply create_worker_reply_; | 265 ViewHostMsg_CreateWorker_Reply create_worker_reply_; |
328 }; | 266 }; |
329 | 267 |
330 void CheckWorkerProcessMsgCreateWorker( | 268 void CheckWorkerProcessMsgCreateWorker( |
331 MockRendererProcessHost* renderer_host, | 269 MockRendererProcessHost* renderer_host, |
332 const std::string& expected_url, | 270 const std::string& expected_url, |
333 const std::string& expected_name, | 271 const std::string& expected_name, |
334 blink::WebContentSecurityPolicyType expected_security_policy_type, | 272 blink::WebContentSecurityPolicyType expected_security_policy_type, |
335 int* route_id) { | 273 int* route_id) { |
336 std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage()); | 274 std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage()); |
337 EXPECT_EQ(WorkerProcessMsg_CreateWorker::ID, msg->type()); | 275 EXPECT_EQ(WorkerProcessMsg_CreateWorker::ID, msg->type()); |
338 std::tuple<WorkerProcessMsg_CreateWorker_Params> param; | 276 std::tuple<WorkerProcessMsg_CreateWorker_Params> param; |
339 EXPECT_TRUE(WorkerProcessMsg_CreateWorker::Read(msg.get(), ¶m)); | 277 EXPECT_TRUE(WorkerProcessMsg_CreateWorker::Read(msg.get(), ¶m)); |
340 EXPECT_EQ(GURL(expected_url), std::get<0>(param).url); | 278 EXPECT_EQ(GURL(expected_url), std::get<0>(param).url); |
341 EXPECT_EQ(base::ASCIIToUTF16(expected_name), std::get<0>(param).name); | 279 EXPECT_EQ(base::ASCIIToUTF16(expected_name), std::get<0>(param).name); |
342 EXPECT_EQ(expected_security_policy_type, | 280 EXPECT_EQ(expected_security_policy_type, |
343 std::get<0>(param).security_policy_type); | 281 std::get<0>(param).security_policy_type); |
344 *route_id = std::get<0>(param).route_id; | 282 *route_id = std::get<0>(param).route_id; |
345 } | 283 } |
346 | 284 |
347 void CheckViewMsgWorkerCreated(MockRendererProcessHost* renderer_host, | 285 void CheckViewMsgWorkerCreated(MockRendererProcessHost* renderer_host, |
348 MockSharedWorkerConnector* connector) { | 286 MockSharedWorkerConnector* connector) { |
349 std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage()); | 287 std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage()); |
350 EXPECT_EQ(ViewMsg_WorkerCreated::ID, msg->type()); | 288 EXPECT_EQ(ViewMsg_WorkerCreated::ID, msg->type()); |
351 EXPECT_EQ(connector->route_id(), msg->routing_id()); | 289 EXPECT_EQ(connector->route_id(), msg->routing_id()); |
352 } | 290 } |
353 | 291 |
354 void CheckMessagePortMsgMessagesQueued(MockRendererProcessHost* renderer_host, | |
355 MockSharedWorkerConnector* connector) { | |
356 std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage()); | |
357 EXPECT_EQ(MessagePortMsg_MessagesQueued::ID, msg->type()); | |
358 EXPECT_EQ(connector->temporary_remote_port_route_id(), msg->routing_id()); | |
359 } | |
360 | |
361 void CheckWorkerMsgConnect(MockRendererProcessHost* renderer_host, | 292 void CheckWorkerMsgConnect(MockRendererProcessHost* renderer_host, |
362 int expected_msg_route_id, | 293 int expected_msg_route_id, |
363 int expected_sent_message_port_id, | 294 int* connection_request_id, |
364 int* routing_id) { | 295 MessagePort* port) { |
365 std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage()); | 296 std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage()); |
366 EXPECT_EQ(WorkerMsg_Connect::ID, msg->type()); | 297 EXPECT_EQ(WorkerMsg_Connect::ID, msg->type()); |
367 EXPECT_EQ(expected_msg_route_id, msg->routing_id()); | 298 EXPECT_EQ(expected_msg_route_id, msg->routing_id()); |
368 WorkerMsg_Connect::Param params; | 299 WorkerMsg_Connect::Param params; |
369 EXPECT_TRUE(WorkerMsg_Connect::Read(msg.get(), ¶ms)); | 300 EXPECT_TRUE(WorkerMsg_Connect::Read(msg.get(), ¶ms)); |
370 int port_id = std::get<0>(params); | 301 *connection_request_id = std::get<0>(params); |
371 *routing_id = std::get<1>(params); | 302 *port = std::get<1>(params); |
372 EXPECT_EQ(expected_sent_message_port_id, port_id); | |
373 } | |
374 | |
375 void CheckMessagePortMsgMessage(MockRendererProcessHost* renderer_host, | |
376 int expected_msg_route_id, | |
377 std::string expected_data) { | |
378 std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage()); | |
379 EXPECT_EQ(MessagePortMsg_Message::ID, msg->type()); | |
380 EXPECT_EQ(expected_msg_route_id, msg->routing_id()); | |
381 MessagePortMsg_Message::Param params; | |
382 EXPECT_TRUE(MessagePortMsg_Message::Read(msg.get(), ¶ms)); | |
383 base::string16 data = std::get<0>(params); | |
384 EXPECT_EQ(base::ASCIIToUTF16(expected_data), data); | |
385 } | 303 } |
386 | 304 |
387 void CheckViewMsgWorkerConnected(MockRendererProcessHost* renderer_host, | 305 void CheckViewMsgWorkerConnected(MockRendererProcessHost* renderer_host, |
388 MockSharedWorkerConnector* connector) { | 306 MockSharedWorkerConnector* connector) { |
389 std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage()); | 307 std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage()); |
390 EXPECT_EQ(ViewMsg_WorkerConnected::ID, msg->type()); | 308 EXPECT_EQ(ViewMsg_WorkerConnected::ID, msg->type()); |
391 EXPECT_EQ(connector->route_id(), msg->routing_id()); | 309 EXPECT_EQ(connector->route_id(), msg->routing_id()); |
392 } | 310 } |
393 | 311 |
394 } // namespace | 312 } // namespace |
395 | 313 |
396 TEST_F(SharedWorkerServiceImplTest, BasicTest) { | 314 TEST_F(SharedWorkerServiceImplTest, BasicTest) { |
397 std::unique_ptr<MockRendererProcessHost> renderer_host( | 315 std::unique_ptr<MockRendererProcessHost> renderer_host( |
398 new MockRendererProcessHost(kProcessIDs[0], | 316 new MockRendererProcessHost(kProcessIDs[0], |
399 browser_context_->GetResourceContext(), | 317 browser_context_->GetResourceContext(), |
400 *partition_.get())); | 318 *partition_.get())); |
401 std::unique_ptr<MockSharedWorkerConnector> connector( | 319 std::unique_ptr<MockSharedWorkerConnector> connector( |
402 new MockSharedWorkerConnector(renderer_host.get())); | 320 new MockSharedWorkerConnector(renderer_host.get())); |
403 int worker_route_id; | 321 int worker_route_id; |
404 int worker_msg_port_route_id; | |
405 | 322 |
406 // SharedWorkerConnector creates two message ports and sends | 323 // Sends ViewHostMsg_CreateWorker. |
407 // ViewHostMsg_CreateWorker. | |
408 connector->Create("http://example.com/w.js", | 324 connector->Create("http://example.com/w.js", |
409 "name", | 325 "name", |
410 kDocumentIDs[0], | 326 kDocumentIDs[0], |
411 kRenderFrameRouteIDs[0]); | 327 kRenderFrameRouteIDs[0]); |
412 // We need to go to UI thread to call ReserveRenderProcessOnUI(). | |
413 RunAllPendingInMessageLoop(); | 328 RunAllPendingInMessageLoop(); |
414 EXPECT_EQ(2U, renderer_host->QueuedMessageCount()); | 329 EXPECT_EQ(2U, renderer_host->QueuedMessageCount()); |
415 // WorkerProcessMsg_CreateWorker should be sent to the renderer in which | 330 // WorkerProcessMsg_CreateWorker should be sent to the renderer in which |
416 // SharedWorker will be created. | 331 // SharedWorker will be created. |
417 CheckWorkerProcessMsgCreateWorker(renderer_host.get(), | 332 CheckWorkerProcessMsgCreateWorker(renderer_host.get(), |
418 "http://example.com/w.js", | 333 "http://example.com/w.js", |
419 "name", | 334 "name", |
420 blink::WebContentSecurityPolicyTypeReport, | 335 blink::WebContentSecurityPolicyTypeReport, |
421 &worker_route_id); | 336 &worker_route_id); |
422 // ViewMsg_WorkerCreated(1) should be sent back to SharedWorkerConnector side. | 337 // ViewMsg_WorkerCreated(1) should be sent back to SharedWorkerConnector side. |
423 CheckViewMsgWorkerCreated(renderer_host.get(), connector.get()); | 338 CheckViewMsgWorkerCreated(renderer_host.get(), connector.get()); |
424 | 339 |
425 // SharedWorkerConnector side sends MessagePortHostMsg_QueueMessages in | |
426 // WebSharedWorkerProxy::connect. | |
427 connector->SendQueueMessages(); | |
428 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); | |
429 // MessagePortMsg_MessagesQueued(2) should be sent back to | |
430 // SharedWorkerConnector side. | |
431 CheckMessagePortMsgMessagesQueued(renderer_host.get(), connector.get()); | |
432 | |
433 // When SharedWorkerConnector receives ViewMsg_WorkerCreated(1), it sends | 340 // When SharedWorkerConnector receives ViewMsg_WorkerCreated(1), it sends |
434 // WorkerMsg_Connect wrapped in ViewHostMsg_ForwardToWorker. | 341 // WorkerMsg_Connect via ViewHostMsg_ConnectToWorker. |
435 connector->SendConnect(); | 342 connector->SendConnect(); |
436 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); | 343 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); |
437 // WorkerMsg_Connect should be sent to SharedWorker side. | 344 // WorkerMsg_Connect should be sent to SharedWorker side. |
438 CheckWorkerMsgConnect(renderer_host.get(), | 345 int worker_msg_connection_request_id; |
439 worker_route_id, | 346 MessagePort worker_msg_port; |
440 connector->remote_port_id(), | 347 CheckWorkerMsgConnect(renderer_host.get(), worker_route_id, |
441 &worker_msg_port_route_id); | 348 &worker_msg_connection_request_id, &worker_msg_port); |
442 | |
443 // When SharedWorkerConnector receives MessagePortMsg_MessagesQueued(2), it | |
444 // sends MessagePortHostMsg_SendQueuedMessages. | |
445 std::vector<QueuedMessage> empty_messages; | |
446 connector->SendSendQueuedMessages(empty_messages); | |
447 EXPECT_EQ(0U, renderer_host->QueuedMessageCount()); | |
448 | 349 |
449 // SharedWorker sends WorkerHostMsg_WorkerReadyForInspection in | 350 // SharedWorker sends WorkerHostMsg_WorkerReadyForInspection in |
450 // EmbeddedSharedWorkerStub::WorkerReadyForInspection(). | 351 // EmbeddedSharedWorkerStub::WorkerReadyForInspection(). |
451 EXPECT_TRUE(renderer_host->OnMessageReceived( | 352 EXPECT_TRUE(renderer_host->OnMessageReceived( |
452 new WorkerHostMsg_WorkerReadyForInspection(worker_route_id))); | 353 new WorkerHostMsg_WorkerReadyForInspection(worker_route_id))); |
453 EXPECT_EQ(0U, renderer_host->QueuedMessageCount()); | 354 EXPECT_EQ(0U, renderer_host->QueuedMessageCount()); |
454 | 355 |
455 // SharedWorker sends WorkerHostMsg_WorkerScriptLoaded in | 356 // SharedWorker sends WorkerHostMsg_WorkerScriptLoaded in |
456 // EmbeddedSharedWorkerStub::workerScriptLoaded(). | 357 // EmbeddedSharedWorkerStub::workerScriptLoaded(). |
457 EXPECT_TRUE(renderer_host->OnMessageReceived( | 358 EXPECT_TRUE(renderer_host->OnMessageReceived( |
458 new WorkerHostMsg_WorkerScriptLoaded(worker_route_id))); | 359 new WorkerHostMsg_WorkerScriptLoaded(worker_route_id))); |
459 EXPECT_EQ(0U, renderer_host->QueuedMessageCount()); | 360 EXPECT_EQ(0U, renderer_host->QueuedMessageCount()); |
460 | 361 |
461 // SharedWorker sends WorkerHostMsg_WorkerConnected in | 362 // SharedWorker sends WorkerHostMsg_WorkerConnected in |
462 // EmbeddedSharedWorkerStub::workerScriptLoaded(). | 363 // EmbeddedSharedWorkerStub::workerScriptLoaded(). |
463 EXPECT_TRUE( | 364 EXPECT_TRUE( |
464 renderer_host->OnMessageReceived(new WorkerHostMsg_WorkerConnected( | 365 renderer_host->OnMessageReceived(new WorkerHostMsg_WorkerConnected( |
465 connector->remote_port_id(), worker_route_id))); | 366 worker_msg_connection_request_id, worker_route_id))); |
466 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); | 367 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); |
467 // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side. | 368 // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side. |
468 CheckViewMsgWorkerConnected(renderer_host.get(), connector.get()); | 369 CheckViewMsgWorkerConnected(renderer_host.get(), connector.get()); |
469 | 370 |
470 // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage, | 371 // Verify that |worker_msg_port| corresponds to |connector->local_port()|. |
471 // SharedWorker side shuold receive MessagePortMsg_Message. | 372 base::string16 expected_message(base::ASCIIToUTF16("test1")); |
472 connector->SendPostMessage("test1"); | 373 connector->local_port().PostMessage(expected_message, |
473 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); | 374 std::vector<MessagePort>()); |
474 CheckMessagePortMsgMessage( | 375 base::string16 received_message; |
475 renderer_host.get(), worker_msg_port_route_id, "test1"); | 376 BlockingReadFromMessagePort(worker_msg_port, &received_message); |
476 | 377 EXPECT_EQ(expected_message, received_message); |
477 // When SharedWorker side sends MessagePortHostMsg_PostMessage, | |
478 // SharedWorkerConnector side shuold receive MessagePortMsg_Message. | |
479 const std::vector<int> empty_ports; | |
480 EXPECT_TRUE( | |
481 renderer_host->OnMessageReceived(new MessagePortHostMsg_PostMessage( | |
482 connector->remote_port_id(), | |
483 base::ASCIIToUTF16("test2"), empty_ports))); | |
484 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); | |
485 CheckMessagePortMsgMessage( | |
486 renderer_host.get(), connector->local_port_route_id(), "test2"); | |
487 | 378 |
488 // UpdateWorkerDependency should not be called. | 379 // UpdateWorkerDependency should not be called. |
489 EXPECT_EQ(0, s_update_worker_dependency_call_count_); | 380 EXPECT_EQ(0, s_update_worker_dependency_call_count_); |
490 } | 381 } |
491 | 382 |
492 TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) { | 383 TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) { |
493 // The first renderer host. | 384 // The first renderer host. |
494 std::unique_ptr<MockRendererProcessHost> renderer_host0( | 385 std::unique_ptr<MockRendererProcessHost> renderer_host0( |
495 new MockRendererProcessHost(kProcessIDs[0], | 386 new MockRendererProcessHost(kProcessIDs[0], |
496 browser_context_->GetResourceContext(), | 387 browser_context_->GetResourceContext(), |
497 *partition_.get())); | 388 *partition_.get())); |
498 std::unique_ptr<MockSharedWorkerConnector> connector0( | 389 std::unique_ptr<MockSharedWorkerConnector> connector0( |
499 new MockSharedWorkerConnector(renderer_host0.get())); | 390 new MockSharedWorkerConnector(renderer_host0.get())); |
500 int worker_route_id; | 391 int worker_route_id; |
501 int worker_msg_port_route_id1; | |
502 | 392 |
503 // SharedWorkerConnector creates two message ports and sends | 393 // Sends ViewHostMsg_CreateWorker. |
504 // ViewHostMsg_CreateWorker. | |
505 connector0->Create("http://example.com/w.js", | 394 connector0->Create("http://example.com/w.js", |
506 "name", | 395 "name", |
507 kDocumentIDs[0], | 396 kDocumentIDs[0], |
508 kRenderFrameRouteIDs[0]); | 397 kRenderFrameRouteIDs[0]); |
509 // We need to go to UI thread to call ReserveRenderProcessOnUI(). | |
510 RunAllPendingInMessageLoop(); | 398 RunAllPendingInMessageLoop(); |
511 EXPECT_EQ(2U, renderer_host0->QueuedMessageCount()); | 399 EXPECT_EQ(2U, renderer_host0->QueuedMessageCount()); |
512 // WorkerProcessMsg_CreateWorker should be sent to the renderer in which | 400 // WorkerProcessMsg_CreateWorker should be sent to the renderer in which |
513 // SharedWorker will be created. | 401 // SharedWorker will be created. |
514 CheckWorkerProcessMsgCreateWorker(renderer_host0.get(), | 402 CheckWorkerProcessMsgCreateWorker(renderer_host0.get(), |
515 "http://example.com/w.js", | 403 "http://example.com/w.js", |
516 "name", | 404 "name", |
517 blink::WebContentSecurityPolicyTypeReport, | 405 blink::WebContentSecurityPolicyTypeReport, |
518 &worker_route_id); | 406 &worker_route_id); |
519 // ViewMsg_WorkerCreated(1) should be sent back to SharedWorkerConnector side. | 407 // ViewMsg_WorkerCreated(1) should be sent back to SharedWorkerConnector side. |
520 CheckViewMsgWorkerCreated(renderer_host0.get(), connector0.get()); | 408 CheckViewMsgWorkerCreated(renderer_host0.get(), connector0.get()); |
521 | 409 |
522 // SharedWorkerConnector side sends MessagePortHostMsg_QueueMessages in | |
523 // WebSharedWorkerProxy::connect. | |
524 connector0->SendQueueMessages(); | |
525 EXPECT_EQ(1U, renderer_host0->QueuedMessageCount()); | |
526 // MessagePortMsg_MessagesQueued(2) should be sent back to | |
527 // SharedWorkerConnector side. | |
528 CheckMessagePortMsgMessagesQueued(renderer_host0.get(), connector0.get()); | |
529 | |
530 // When SharedWorkerConnector receives ViewMsg_WorkerCreated(1), it sends | 410 // When SharedWorkerConnector receives ViewMsg_WorkerCreated(1), it sends |
531 // WorkerMsg_Connect wrapped in ViewHostMsg_ForwardToWorker. | 411 // WorkerMsg_Connect wrapped in ViewHostMsg_ForwardToWorker. |
532 connector0->SendConnect(); | 412 connector0->SendConnect(); |
533 EXPECT_EQ(1U, renderer_host0->QueuedMessageCount()); | 413 EXPECT_EQ(1U, renderer_host0->QueuedMessageCount()); |
534 // WorkerMsg_Connect should be sent to SharedWorker side. | 414 // WorkerMsg_Connect should be sent to SharedWorker side. |
535 CheckWorkerMsgConnect(renderer_host0.get(), | 415 int worker_msg_connection_request_id1; |
536 worker_route_id, | 416 MessagePort worker_msg_port1; |
537 connector0->remote_port_id(), | 417 CheckWorkerMsgConnect(renderer_host0.get(), worker_route_id, |
538 &worker_msg_port_route_id1); | 418 &worker_msg_connection_request_id1, &worker_msg_port1); |
539 | |
540 // When SharedWorkerConnector receives MessagePortMsg_MessagesQueued(2), it | |
541 // sends MessagePortHostMsg_SendQueuedMessages. | |
542 std::vector<QueuedMessage> empty_messages; | |
543 connector0->SendSendQueuedMessages(empty_messages); | |
544 EXPECT_EQ(0U, renderer_host0->QueuedMessageCount()); | |
545 | 419 |
546 // SharedWorker sends WorkerHostMsg_WorkerReadyForInspection in | 420 // SharedWorker sends WorkerHostMsg_WorkerReadyForInspection in |
547 // EmbeddedSharedWorkerStub::WorkerReadyForInspection(). | 421 // EmbeddedSharedWorkerStub::WorkerReadyForInspection(). |
548 EXPECT_TRUE(renderer_host0->OnMessageReceived( | 422 EXPECT_TRUE(renderer_host0->OnMessageReceived( |
549 new WorkerHostMsg_WorkerReadyForInspection(worker_route_id))); | 423 new WorkerHostMsg_WorkerReadyForInspection(worker_route_id))); |
550 EXPECT_EQ(0U, renderer_host0->QueuedMessageCount()); | 424 EXPECT_EQ(0U, renderer_host0->QueuedMessageCount()); |
551 | 425 |
552 // SharedWorker sends WorkerHostMsg_WorkerScriptLoaded in | 426 // SharedWorker sends WorkerHostMsg_WorkerScriptLoaded in |
553 // EmbeddedSharedWorkerStub::workerScriptLoaded(). | 427 // EmbeddedSharedWorkerStub::workerScriptLoaded(). |
554 EXPECT_TRUE(renderer_host0->OnMessageReceived( | 428 EXPECT_TRUE(renderer_host0->OnMessageReceived( |
555 new WorkerHostMsg_WorkerScriptLoaded(worker_route_id))); | 429 new WorkerHostMsg_WorkerScriptLoaded(worker_route_id))); |
556 EXPECT_EQ(0U, renderer_host0->QueuedMessageCount()); | 430 EXPECT_EQ(0U, renderer_host0->QueuedMessageCount()); |
557 | 431 |
558 // SharedWorker sends WorkerHostMsg_WorkerConnected in | 432 // SharedWorker sends WorkerHostMsg_WorkerConnected in |
559 // EmbeddedSharedWorkerStub::workerScriptLoaded(). | 433 // EmbeddedSharedWorkerStub::workerScriptLoaded(). |
560 EXPECT_TRUE( | 434 EXPECT_TRUE( |
561 renderer_host0->OnMessageReceived(new WorkerHostMsg_WorkerConnected( | 435 renderer_host0->OnMessageReceived(new WorkerHostMsg_WorkerConnected( |
562 connector0->remote_port_id(), worker_route_id))); | 436 worker_msg_connection_request_id1, worker_route_id))); |
563 EXPECT_EQ(1U, renderer_host0->QueuedMessageCount()); | 437 EXPECT_EQ(1U, renderer_host0->QueuedMessageCount()); |
564 // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side. | 438 // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side. |
565 CheckViewMsgWorkerConnected(renderer_host0.get(), connector0.get()); | 439 CheckViewMsgWorkerConnected(renderer_host0.get(), connector0.get()); |
566 | 440 |
567 // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage, | 441 // Verify that |worker_msg_port1| corresponds to |connector0->local_port()|. |
568 // SharedWorker side shuold receive MessagePortMsg_Message. | 442 base::string16 expected_message1(base::ASCIIToUTF16("test1")); |
569 connector0->SendPostMessage("test1"); | 443 connector0->local_port().PostMessage(expected_message1, |
570 EXPECT_EQ(1U, renderer_host0->QueuedMessageCount()); | 444 std::vector<MessagePort>()); |
571 CheckMessagePortMsgMessage( | 445 base::string16 received_message1; |
572 renderer_host0.get(), worker_msg_port_route_id1, "test1"); | 446 BlockingReadFromMessagePort(worker_msg_port1, &received_message1); |
573 | 447 EXPECT_EQ(expected_message1, received_message1); |
574 // When SharedWorker side sends MessagePortHostMsg_PostMessage, | |
575 // SharedWorkerConnector side shuold receive MessagePortMsg_Message. | |
576 const std::vector<int> empty_ports; | |
577 EXPECT_TRUE( | |
578 renderer_host0->OnMessageReceived(new MessagePortHostMsg_PostMessage( | |
579 connector0->remote_port_id(), | |
580 base::ASCIIToUTF16("test2"), empty_ports))); | |
581 EXPECT_EQ(1U, renderer_host0->QueuedMessageCount()); | |
582 CheckMessagePortMsgMessage( | |
583 renderer_host0.get(), connector0->local_port_route_id(), "test2"); | |
584 | 448 |
585 // The second renderer host. | 449 // The second renderer host. |
586 std::unique_ptr<MockRendererProcessHost> renderer_host1( | 450 std::unique_ptr<MockRendererProcessHost> renderer_host1( |
587 new MockRendererProcessHost(kProcessIDs[1], | 451 new MockRendererProcessHost(kProcessIDs[1], |
588 browser_context_->GetResourceContext(), | 452 browser_context_->GetResourceContext(), |
589 *partition_.get())); | 453 *partition_.get())); |
590 std::unique_ptr<MockSharedWorkerConnector> connector1( | 454 std::unique_ptr<MockSharedWorkerConnector> connector1( |
591 new MockSharedWorkerConnector(renderer_host1.get())); | 455 new MockSharedWorkerConnector(renderer_host1.get())); |
592 int worker_msg_port_route_id2; | |
593 | 456 |
594 // UpdateWorkerDependency should not be called yet. | 457 // UpdateWorkerDependency should not be called yet. |
595 EXPECT_EQ(0, s_update_worker_dependency_call_count_); | 458 EXPECT_EQ(0, s_update_worker_dependency_call_count_); |
596 | 459 |
597 // SharedWorkerConnector creates two message ports and sends | 460 // SharedWorkerConnector creates two message ports and sends |
598 // ViewHostMsg_CreateWorker. | 461 // ViewHostMsg_CreateWorker. |
599 connector1->Create("http://example.com/w.js", | 462 connector1->Create("http://example.com/w.js", |
600 "name", | 463 "name", |
601 kDocumentIDs[1], | 464 kDocumentIDs[1], |
602 kRenderFrameRouteIDs[1]); | 465 kRenderFrameRouteIDs[1]); |
603 // We need to go to UI thread to call ReserveRenderProcessOnUI(). | 466 // We need to go to UI thread to call ReserveRenderProcessOnUI(). |
604 RunAllPendingInMessageLoop(); | 467 RunAllPendingInMessageLoop(); |
605 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); | 468 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); |
606 // ViewMsg_WorkerCreated(3) should be sent back to SharedWorkerConnector side. | 469 // ViewMsg_WorkerCreated(3) should be sent back to SharedWorkerConnector side. |
607 CheckViewMsgWorkerCreated(renderer_host1.get(), connector1.get()); | 470 CheckViewMsgWorkerCreated(renderer_host1.get(), connector1.get()); |
608 | 471 |
609 // UpdateWorkerDependency should be called. | 472 // UpdateWorkerDependency should be called. |
610 EXPECT_EQ(1, s_update_worker_dependency_call_count_); | 473 EXPECT_EQ(1, s_update_worker_dependency_call_count_); |
611 EXPECT_EQ(1U, s_worker_dependency_added_ids_.size()); | 474 EXPECT_EQ(1U, s_worker_dependency_added_ids_.size()); |
612 EXPECT_EQ(kProcessIDs[0], s_worker_dependency_added_ids_[0]); | 475 EXPECT_EQ(kProcessIDs[0], s_worker_dependency_added_ids_[0]); |
613 EXPECT_EQ(0U, s_worker_dependency_removed_ids_.size()); | 476 EXPECT_EQ(0U, s_worker_dependency_removed_ids_.size()); |
614 | 477 |
615 // SharedWorkerConnector side sends MessagePortHostMsg_QueueMessages in | |
616 // WebSharedWorkerProxy::connect. | |
617 connector1->SendQueueMessages(); | |
618 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); | |
619 // MessagePortMsg_MessagesQueued(4) should be sent back to | |
620 // SharedWorkerConnector side. | |
621 CheckMessagePortMsgMessagesQueued(renderer_host1.get(), connector1.get()); | |
622 | |
623 // When SharedWorkerConnector receives ViewMsg_WorkerCreated(3), it sends | 478 // When SharedWorkerConnector receives ViewMsg_WorkerCreated(3), it sends |
624 // WorkerMsg_Connect wrapped in ViewHostMsg_ForwardToWorker. | 479 // WorkerMsg_Connect wrapped in ViewHostMsg_ForwardToWorker. |
625 connector1->SendConnect(); | 480 connector1->SendConnect(); |
626 EXPECT_EQ(1U, renderer_host0->QueuedMessageCount()); | 481 EXPECT_EQ(1U, renderer_host0->QueuedMessageCount()); |
627 // WorkerMsg_Connect should be sent to SharedWorker side. | 482 // WorkerMsg_Connect should be sent to SharedWorker side. |
628 CheckWorkerMsgConnect(renderer_host0.get(), | 483 int worker_msg_connection_request_id2; |
629 worker_route_id, | 484 MessagePort worker_msg_port2; |
630 connector1->remote_port_id(), | 485 CheckWorkerMsgConnect(renderer_host0.get(), worker_route_id, |
631 &worker_msg_port_route_id2); | 486 &worker_msg_connection_request_id2, &worker_msg_port2); |
632 | |
633 // When SharedWorkerConnector receives MessagePortMsg_MessagesQueued(4), it | |
634 // sends MessagePortHostMsg_SendQueuedMessages. | |
635 connector1->SendSendQueuedMessages(empty_messages); | |
636 EXPECT_EQ(0U, renderer_host1->QueuedMessageCount()); | |
637 | 487 |
638 // SharedWorker sends WorkerHostMsg_WorkerConnected in | 488 // SharedWorker sends WorkerHostMsg_WorkerConnected in |
639 // EmbeddedSharedWorkerStub::OnConnect(). | 489 // EmbeddedSharedWorkerStub::OnConnect(). |
640 EXPECT_TRUE( | 490 EXPECT_TRUE( |
641 renderer_host0->OnMessageReceived(new WorkerHostMsg_WorkerConnected( | 491 renderer_host0->OnMessageReceived(new WorkerHostMsg_WorkerConnected( |
642 connector1->remote_port_id(), worker_route_id))); | 492 worker_msg_connection_request_id2, worker_route_id))); |
643 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); | 493 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); |
644 // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side. | 494 // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side. |
645 CheckViewMsgWorkerConnected(renderer_host1.get(), connector1.get()); | 495 CheckViewMsgWorkerConnected(renderer_host1.get(), connector1.get()); |
646 | 496 |
647 // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage, | 497 // Verify that |worker_msg_port2| corresponds to |connector1->local_port()|. |
648 // SharedWorker side shuold receive MessagePortMsg_Message. | 498 base::string16 expected_message2(base::ASCIIToUTF16("test2")); |
649 connector1->SendPostMessage("test3"); | 499 connector1->local_port().PostMessage(expected_message2, |
650 EXPECT_EQ(1U, renderer_host0->QueuedMessageCount()); | 500 std::vector<MessagePort>()); |
651 CheckMessagePortMsgMessage( | 501 base::string16 received_message2; |
652 renderer_host0.get(), worker_msg_port_route_id2, "test3"); | 502 BlockingReadFromMessagePort(worker_msg_port2, &received_message2); |
653 | 503 EXPECT_EQ(expected_message2, received_message2); |
654 // When SharedWorker side sends MessagePortHostMsg_PostMessage, | |
655 // SharedWorkerConnector side shuold receive MessagePortMsg_Message. | |
656 EXPECT_TRUE( | |
657 renderer_host0->OnMessageReceived(new MessagePortHostMsg_PostMessage( | |
658 connector1->remote_port_id(), | |
659 base::ASCIIToUTF16("test4"), empty_ports))); | |
660 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); | |
661 CheckMessagePortMsgMessage( | |
662 renderer_host1.get(), connector1->local_port_route_id(), "test4"); | |
663 | 504 |
664 EXPECT_EQ(1, s_update_worker_dependency_call_count_); | 505 EXPECT_EQ(1, s_update_worker_dependency_call_count_); |
665 renderer_host1.reset(); | 506 renderer_host1.reset(); |
666 // UpdateWorkerDependency should be called. | 507 // UpdateWorkerDependency should be called. |
667 EXPECT_EQ(2, s_update_worker_dependency_call_count_); | 508 EXPECT_EQ(2, s_update_worker_dependency_call_count_); |
668 EXPECT_EQ(0U, s_worker_dependency_added_ids_.size()); | 509 EXPECT_EQ(0U, s_worker_dependency_added_ids_.size()); |
669 EXPECT_EQ(1U, s_worker_dependency_removed_ids_.size()); | 510 EXPECT_EQ(1U, s_worker_dependency_removed_ids_.size()); |
670 EXPECT_EQ(kProcessIDs[0], s_worker_dependency_removed_ids_[0]); | 511 EXPECT_EQ(kProcessIDs[0], s_worker_dependency_removed_ids_[0]); |
671 } | 512 } |
672 | 513 |
(...skipping 304 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
977 kDocumentIDs[2], | 818 kDocumentIDs[2], |
978 kRenderFrameRouteIDs[2]); | 819 kRenderFrameRouteIDs[2]); |
979 EXPECT_NE(MSG_ROUTING_NONE, connector2->route_id()); | 820 EXPECT_NE(MSG_ROUTING_NONE, connector2->route_id()); |
980 EXPECT_EQ(0U, renderer_host2->QueuedMessageCount()); | 821 EXPECT_EQ(0U, renderer_host2->QueuedMessageCount()); |
981 RunAllPendingInMessageLoop(); | 822 RunAllPendingInMessageLoop(); |
982 EXPECT_EQ(1U, renderer_host2->QueuedMessageCount()); | 823 EXPECT_EQ(1U, renderer_host2->QueuedMessageCount()); |
983 CheckViewMsgWorkerCreated(renderer_host2.get(), connector2.get()); | 824 CheckViewMsgWorkerCreated(renderer_host2.get(), connector2.get()); |
984 } | 825 } |
985 | 826 |
986 } // namespace content | 827 } // namespace content |
OLD | NEW |