OLD | NEW |
---|---|
(Empty) | |
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 | |
3 // found in the LICENSE file. | |
4 | |
5 #include <map> | |
6 #include <vector> | |
7 | |
8 #include "base/atomic_sequence_num.h" | |
9 #include "base/basictypes.h" | |
10 #include "base/memory/scoped_ptr.h" | |
11 #include "base/memory/scoped_vector.h" | |
12 #include "base/strings/string16.h" | |
13 #include "base/strings/utf_string_conversions.h" | |
14 #include "content/browser/message_port_message_filter.h" | |
15 #include "content/browser/shared_worker/shared_worker_message_filter.h" | |
16 #include "content/browser/shared_worker/shared_worker_service_impl.h" | |
17 #include "content/browser/worker_host/worker_storage_partition.h" | |
18 #include "content/common/message_port_messages.h" | |
19 #include "content/common/view_messages.h" | |
20 #include "content/common/worker_messages.h" | |
21 #include "content/public/test/test_browser_context.h" | |
22 #include "content/public/test/test_browser_thread_bundle.h" | |
23 #include "ipc/ipc_sync_message.h" | |
24 #include "testing/gtest/include/gtest/gtest.h" | |
25 | |
26 namespace content { | |
27 namespace { | |
28 | |
29 class MockMessagePortMessageFilter : public MessagePortMessageFilter { | |
30 public: | |
31 MockMessagePortMessageFilter(const NextRoutingIDCallback& callback, | |
32 ScopedVector<IPC::Message>* message_queue) | |
33 : MessagePortMessageFilter(callback), message_queue_(message_queue) {} | |
34 | |
35 virtual bool Send(IPC::Message* message) OVERRIDE { | |
36 if (message_queue_) | |
37 message_queue_->push_back(message); | |
38 return true; | |
39 } | |
40 | |
41 void Close() { | |
42 message_queue_ = NULL; | |
43 OnChannelClosing(); | |
44 } | |
45 | |
46 private: | |
47 virtual ~MockMessagePortMessageFilter() {} | |
48 ScopedVector<IPC::Message>* message_queue_; | |
49 }; | |
50 | |
51 class MockSharedWorkerMessageFilter : public SharedWorkerMessageFilter { | |
52 public: | |
53 MockSharedWorkerMessageFilter(int render_process_id, | |
54 ResourceContext* resource_context, | |
55 const WorkerStoragePartition& partition, | |
56 MessagePortMessageFilter* message_port_filter, | |
57 ScopedVector<IPC::Message>* message_queue) | |
58 : SharedWorkerMessageFilter(render_process_id, | |
59 resource_context, | |
60 partition, | |
61 message_port_filter), | |
62 message_queue_(message_queue) {} | |
63 | |
64 virtual bool Send(IPC::Message* message) OVERRIDE { | |
65 if (message_queue_) | |
66 message_queue_->push_back(message); | |
67 return true; | |
68 } | |
69 | |
70 void Close() { | |
71 message_queue_ = NULL; | |
72 OnChannelClosing(); | |
73 } | |
74 | |
75 private: | |
76 virtual ~MockSharedWorkerMessageFilter() {} | |
77 ScopedVector<IPC::Message>* message_queue_; | |
78 }; | |
79 | |
80 class MockRendererProcessHost { | |
81 public: | |
82 MockRendererProcessHost(int process_no, | |
kinuko
2014/03/11 05:35:41
nit: process_no -> process_id to match the terms w
horo
2014/03/11 06:55:56
Done.
| |
83 ResourceContext* resource_context, | |
84 const WorkerStoragePartition& partition) | |
85 : message_filter_(new MockMessagePortMessageFilter( | |
86 base::Bind(&base::AtomicSequenceNumber::GetNext, | |
87 base::Unretained(&next_routing_id_)), | |
88 &queued_messages_)), | |
89 worker_filter_(new MockSharedWorkerMessageFilter(process_no, | |
90 resource_context, | |
91 partition, | |
92 message_filter_.get(), | |
93 &queued_messages_)) {} | |
94 | |
95 ~MockRendererProcessHost() { | |
96 message_filter_->Close(); | |
97 worker_filter_->Close(); | |
98 } | |
99 | |
100 bool OnMessageReceived(IPC::Message* message) { | |
101 scoped_ptr<IPC::Message> msg(message); | |
102 bool message_was_ok = false; | |
103 const bool ret = | |
104 message_filter_->OnMessageReceived(*message, &message_was_ok) || | |
105 worker_filter_->OnMessageReceived(*message, &message_was_ok); | |
106 if (message->is_sync()) { | |
107 CHECK(!queued_messages_.empty()); | |
108 const IPC::Message* response_msg = queued_messages_.back(); | |
109 IPC::SyncMessage* sync_msg = static_cast<IPC::SyncMessage*>(message); | |
110 scoped_ptr<IPC::MessageReplyDeserializer> reply_serializer( | |
111 sync_msg->GetReplyDeserializer()); | |
112 bool result = reply_serializer->SerializeOutputParameters(*response_msg); | |
113 CHECK(result); | |
114 queued_messages_.pop_back(); | |
115 } | |
116 return ret; | |
117 } | |
118 | |
119 size_t QueuedMessageCount() const { return queued_messages_.size(); } | |
120 | |
121 scoped_ptr<IPC::Message> PopMessage() { | |
122 CHECK(queued_messages_.size()); | |
123 scoped_ptr<IPC::Message> msg(*queued_messages_.begin()); | |
124 queued_messages_.weak_erase(queued_messages_.begin()); | |
125 return msg.Pass(); | |
126 } | |
127 | |
128 private: | |
129 ScopedVector<IPC::Message> queued_messages_; | |
130 base::AtomicSequenceNumber next_routing_id_; | |
131 scoped_refptr<MockMessagePortMessageFilter> message_filter_; | |
132 scoped_refptr<MockSharedWorkerMessageFilter> worker_filter_; | |
133 }; | |
134 | |
135 void CreateMessagePortPair(MockRendererProcessHost* renderer, | |
136 int* route_1, | |
137 int* port_1, | |
138 int* route_2, | |
139 int* port_2) { | |
140 EXPECT_TRUE(renderer->OnMessageReceived( | |
141 new MessagePortHostMsg_CreateMessagePort(route_1, port_1))); | |
142 EXPECT_TRUE(renderer->OnMessageReceived( | |
143 new MessagePortHostMsg_CreateMessagePort(route_2, port_2))); | |
144 EXPECT_TRUE(renderer->OnMessageReceived( | |
145 new MessagePortHostMsg_Entangle(*port_1, *port_2))); | |
146 EXPECT_TRUE(renderer->OnMessageReceived( | |
147 new MessagePortHostMsg_Entangle(*port_2, *port_1))); | |
148 } | |
149 | |
150 void PostCreateWorker(MockRendererProcessHost* renderer, | |
151 const std::string& url, | |
152 const std::string& name, | |
153 unsigned long long document_id, | |
154 int render_frame_route_id, | |
155 int* connector_route_id) { | |
156 ViewHostMsg_CreateWorker_Params params; | |
157 params.url = GURL(url); | |
158 params.name = base::ASCIIToUTF16(name); | |
159 params.content_security_policy = base::string16(); | |
160 params.security_policy_type = blink::WebContentSecurityPolicyTypeReport; | |
161 params.document_id = document_id; | |
162 params.render_frame_route_id = render_frame_route_id; | |
163 EXPECT_TRUE(renderer->OnMessageReceived( | |
164 new ViewHostMsg_CreateWorker(params, connector_route_id))); | |
165 } | |
166 | |
167 void CheckWorkerProcessMsgCreateWorker( | |
168 scoped_ptr<IPC::Message> msg, | |
169 const std::string& expected_url, | |
170 const std::string& expected_name, | |
171 blink::WebContentSecurityPolicyType expected_security_policy_type, | |
172 int* route_id) { | |
173 EXPECT_EQ(WorkerProcessMsg_CreateWorker::ID, msg->type()); | |
174 Tuple1<WorkerProcessMsg_CreateWorker_Params> param; | |
175 EXPECT_TRUE(WorkerProcessMsg_CreateWorker::Read(msg.get(), ¶m)); | |
176 EXPECT_EQ(GURL(expected_url), param.a.url); | |
177 EXPECT_EQ(base::ASCIIToUTF16(expected_name), param.a.name); | |
178 EXPECT_EQ(expected_security_policy_type, param.a.security_policy_type); | |
179 *route_id = param.a.route_id; | |
180 } | |
181 | |
182 void CheckViewMsgWorkerCreated(scoped_ptr<IPC::Message> msg, | |
183 int expected_msg_route_id) { | |
184 EXPECT_EQ(ViewMsg_WorkerCreated::ID, msg->type()); | |
185 EXPECT_EQ(expected_msg_route_id, msg->routing_id()); | |
186 } | |
187 | |
188 void CheckMessagePortMsgMessagesQueued(scoped_ptr<IPC::Message> msg, | |
189 int expected_msg_route_id) { | |
190 EXPECT_EQ(MessagePortMsg_MessagesQueued::ID, msg->type()); | |
191 EXPECT_EQ(expected_msg_route_id, msg->routing_id()); | |
192 } | |
193 | |
194 void CheckWorkerMsgConnect(scoped_ptr<IPC::Message> msg, | |
195 int expected_msg_route_id, | |
196 int expected_sent_message_port_id, | |
197 int* routing_id) { | |
198 EXPECT_EQ(WorkerMsg_Connect::ID, msg->type()); | |
199 EXPECT_EQ(expected_msg_route_id, msg->routing_id()); | |
200 int port_id; | |
201 EXPECT_TRUE(WorkerMsg_Connect::Read(msg.get(), &port_id, routing_id)); | |
202 EXPECT_EQ(expected_sent_message_port_id, port_id); | |
203 } | |
204 | |
205 void CheckMessagePortMsgMessage(scoped_ptr<IPC::Message> msg, | |
206 int expected_msg_route_id, | |
207 std::string expected_data) { | |
208 EXPECT_EQ(MessagePortMsg_Message::ID, msg->type()); | |
209 EXPECT_EQ(expected_msg_route_id, msg->routing_id()); | |
210 base::string16 data; | |
211 std::vector<int> sent_message_port_ids; | |
212 std::vector<int> new_routing_ids; | |
213 EXPECT_TRUE(MessagePortMsg_Message::Read( | |
214 msg.get(), &data, &sent_message_port_ids, &new_routing_ids)); | |
215 EXPECT_EQ(base::ASCIIToUTF16(expected_data), data); | |
216 } | |
217 | |
218 void CheckViewMsgWorkerConnected(scoped_ptr<IPC::Message> msg, | |
219 int expected_msg_route_id) { | |
220 EXPECT_EQ(ViewMsg_WorkerConnected::ID, msg->type()); | |
221 EXPECT_EQ(expected_msg_route_id, msg->routing_id()); | |
222 } | |
223 | |
224 class MockSharedWorkerConnector { | |
225 public: | |
226 MockSharedWorkerConnector(MockRendererProcessHost* renderer_host) | |
227 : renderer_host_(renderer_host) {} | |
228 void Create(const std::string& url, | |
229 const std::string& name, | |
230 unsigned long long document_id, | |
231 int render_frame_route_id) { | |
232 CreateMessagePortPair(renderer_host_, | |
233 &temporary_remote_port_route_id_, | |
234 &remote_port_id_, | |
235 &local_port_route_id_, | |
236 &local_port_id_); | |
237 PostCreateWorker(renderer_host_, | |
238 url, | |
239 name, | |
240 document_id, | |
241 render_frame_route_id, | |
242 &route_id_); | |
243 } | |
244 void SendQueueMessages() { | |
245 EXPECT_TRUE(renderer_host_->OnMessageReceived( | |
246 new MessagePortHostMsg_QueueMessages(remote_port_id_))); | |
247 } | |
248 void SendPostMessage(std::string data) { | |
249 const std::vector<int> empty_ids; | |
250 EXPECT_TRUE( | |
251 renderer_host_->OnMessageReceived(new MessagePortHostMsg_PostMessage( | |
252 local_port_id_, base::ASCIIToUTF16(data), empty_ids))); | |
253 } | |
254 void SendConnect() { | |
255 EXPECT_TRUE( | |
256 renderer_host_->OnMessageReceived(new ViewHostMsg_ForwardToWorker( | |
257 WorkerMsg_Connect(route_id_, remote_port_id_, MSG_ROUTING_NONE)))); | |
258 } | |
259 void SendSendQueuedMessages( | |
260 const std::vector<QueuedMessage>& queued_messages) { | |
261 EXPECT_TRUE(renderer_host_->OnMessageReceived( | |
262 new MessagePortHostMsg_SendQueuedMessages(remote_port_id_, | |
263 queued_messages))); | |
264 } | |
265 int temporary_remote_port_route_id() { | |
266 return temporary_remote_port_route_id_; | |
267 } | |
268 int remote_port_id() { return remote_port_id_; } | |
269 int local_port_route_id() { return local_port_route_id_; } | |
270 int local_port_id() { return local_port_id_; } | |
271 int route_id() { return route_id_; } | |
272 | |
273 private: | |
274 MockRendererProcessHost* renderer_host_; | |
275 int temporary_remote_port_route_id_; | |
276 int remote_port_id_; | |
277 int local_port_route_id_; | |
278 int local_port_id_; | |
279 int route_id_; | |
280 }; | |
281 | |
282 } // namespace | |
283 | |
284 class SharedWorkerServiceImplTest : public testing::Test { | |
285 protected: | |
286 SharedWorkerServiceImplTest() | |
287 : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP), | |
288 browser_context_(new TestBrowserContext()), | |
289 partition_( | |
290 new WorkerStoragePartition(browser_context_->GetRequestContext(), | |
291 NULL, | |
292 NULL, | |
293 NULL, | |
294 NULL, | |
295 NULL, | |
296 NULL)) { | |
297 SharedWorkerServiceImpl::GetInstance() | |
298 ->ChangeUpdateWorkerDependencyFuncForTesting( | |
299 &SharedWorkerServiceImplTest::MockUpdateWorkerDependency); | |
300 } | |
301 | |
302 virtual void SetUp() OVERRIDE {} | |
303 virtual void TearDown() OVERRIDE { | |
304 s_update_worker_dependency_call_count_ = 0; | |
305 s_worker_dependency_added_ids_.clear(); | |
306 s_worker_dependency_removed_ids_.clear(); | |
307 SharedWorkerServiceImpl::GetInstance()->ResetForTesting(); | |
308 } | |
309 static void MockUpdateWorkerDependency(const std::vector<int>& added_ids, | |
310 const std::vector<int>& removed_ids) { | |
311 ++s_update_worker_dependency_call_count_; | |
312 s_worker_dependency_added_ids_ = added_ids; | |
313 s_worker_dependency_removed_ids_ = removed_ids; | |
314 } | |
315 | |
316 TestBrowserThreadBundle browser_thread_bundle_; | |
317 scoped_ptr<TestBrowserContext> browser_context_; | |
318 scoped_ptr<WorkerStoragePartition> partition_; | |
319 static int s_update_worker_dependency_call_count_; | |
320 static std::vector<int> s_worker_dependency_added_ids_; | |
321 static std::vector<int> s_worker_dependency_removed_ids_; | |
322 DISALLOW_COPY_AND_ASSIGN(SharedWorkerServiceImplTest); | |
323 }; | |
324 | |
325 // static | |
326 int SharedWorkerServiceImplTest::s_update_worker_dependency_call_count_; | |
327 std::vector<int> SharedWorkerServiceImplTest::s_worker_dependency_added_ids_; | |
328 std::vector<int> SharedWorkerServiceImplTest::s_worker_dependency_removed_ids_; | |
329 | |
330 TEST_F(SharedWorkerServiceImplTest, SimpleTest) { | |
kinuko
2014/03/11 05:35:41
Um... Simple -> Basic maybe? (Still doesn't look s
horo
2014/03/11 06:55:56
Done.
| |
331 scoped_ptr<MockRendererProcessHost> renderer_host(new MockRendererProcessHost( | |
332 100, browser_context_->GetResourceContext(), *partition_.get())); | |
333 scoped_ptr<MockSharedWorkerConnector> connector( | |
334 new MockSharedWorkerConnector(renderer_host.get())); | |
335 int worker_route_id; | |
336 int worker_msg_port_route_id; | |
337 | |
338 // SharedWorkerConnector creates two message ports and sends | |
339 // ViewHostMsg_CreateWorker_Params. | |
kinuko
2014/03/11 05:35:41
Thanks for adding very descriptive comments, but I
| |
340 connector->Create("http://example.com/w.js", "name", 200, 300); | |
341 EXPECT_EQ(2U, renderer_host->QueuedMessageCount()); | |
342 // WorkerProcessMsg_CreateWorker shoud be sent to the renderer in which | |
kinuko
2014/03/11 05:35:41
shoud -> should (here and below)
horo
2014/03/11 06:55:56
Done.
| |
343 // SharedWorker will be created. | |
344 CheckWorkerProcessMsgCreateWorker(renderer_host->PopMessage(), | |
345 "http://example.com/w.js", | |
346 "name", | |
347 blink::WebContentSecurityPolicyTypeReport, | |
348 &worker_route_id); | |
349 // ViewMsg_WorkerCreated(1) shoud be sent back to SharedWorkerConnector side. | |
350 CheckViewMsgWorkerCreated(renderer_host->PopMessage(), connector->route_id()); | |
351 | |
352 // SharedWorkerConnector side sends MessagePortHostMsg_QueueMessages in | |
353 // WebSharedWorkerProxy::connect. | |
354 connector->SendQueueMessages(); | |
355 EXPECT_EQ(1, renderer_host->QueuedMessageCount()); | |
356 // MessagePortMsg_MessagesQueued(2) shoud be sent back to | |
357 // SharedWorkerConnector side. | |
358 CheckMessagePortMsgMessagesQueued( | |
359 renderer_host->PopMessage(), connector->temporary_remote_port_route_id()); | |
360 | |
361 // When SharedWorkerConnector recieves ViewMsg_WorkerCreated(1), it sends | |
kinuko
2014/03/11 05:35:41
recieve -> receive (here and below)
horo
2014/03/11 06:55:56
Done.
| |
362 // WorkerMsg_Connect wrapped in ViewHostMsg_ForwardToWorker. | |
363 connector->SendConnect(); | |
364 EXPECT_EQ(1, renderer_host->QueuedMessageCount()); | |
365 // WorkerMsg_Connect shoud be sent to SharedWorker side. | |
366 CheckWorkerMsgConnect(renderer_host->PopMessage(), | |
367 worker_route_id, | |
368 connector->remote_port_id(), | |
369 &worker_msg_port_route_id); | |
370 | |
371 // When SharedWorkerConnector recieves MessagePortMsg_MessagesQueued(2), it | |
372 // sends MessagePortHostMsg_SendQueuedMessages. | |
373 std::vector<QueuedMessage> empty_messages; | |
374 connector->SendSendQueuedMessages(empty_messages); | |
375 EXPECT_EQ(0, renderer_host->QueuedMessageCount()); | |
376 | |
377 // SharedWorker sends WorkerHostMsg_WorkerScriptLoaded in | |
378 // EmbeddedSharedWorkerStub::workerScriptLoaded(). | |
379 EXPECT_TRUE(renderer_host->OnMessageReceived( | |
380 new WorkerHostMsg_WorkerScriptLoaded(worker_route_id))); | |
381 EXPECT_EQ(0, renderer_host->QueuedMessageCount()); | |
382 | |
383 // SharedWorker sends WorkerHostMsg_WorkerConnected in | |
384 // EmbeddedSharedWorkerStub::workerScriptLoaded(). | |
385 EXPECT_TRUE( | |
386 renderer_host->OnMessageReceived(new WorkerHostMsg_WorkerConnected( | |
387 connector->remote_port_id(), worker_route_id))); | |
388 EXPECT_EQ(1, renderer_host->QueuedMessageCount()); | |
389 // ViewMsg_WorkerConnected shoud be sent to SharedWorkerConnector side. | |
390 CheckViewMsgWorkerConnected(renderer_host->PopMessage(), | |
391 connector->route_id()); | |
392 | |
393 // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage, | |
394 // SharedWorker side shuold recieve MessagePortMsg_Message. | |
kinuko
2014/03/11 05:35:41
shuold -> should (here and below)
horo
2014/03/11 06:55:56
Done.
| |
395 connector->SendPostMessage("test1"); | |
396 EXPECT_EQ(1, renderer_host->QueuedMessageCount()); | |
397 CheckMessagePortMsgMessage( | |
398 renderer_host->PopMessage(), worker_msg_port_route_id, "test1"); | |
399 | |
400 // When SharedWorker side sends MessagePortHostMsg_PostMessage, | |
401 // SharedWorkerConnector side shuold recieve MessagePortMsg_Message. | |
402 const std::vector<int> empty_ids; | |
403 EXPECT_TRUE(renderer_host->OnMessageReceived( | |
404 new MessagePortHostMsg_PostMessage(connector->remote_port_id(), | |
405 base::ASCIIToUTF16("test2"), | |
406 empty_ids))); | |
407 EXPECT_EQ(1, renderer_host->QueuedMessageCount()); | |
408 CheckMessagePortMsgMessage( | |
409 renderer_host->PopMessage(), connector->local_port_route_id(), "test2"); | |
410 | |
411 // UpdateWorkerDependency should not be called. | |
412 EXPECT_EQ(0, s_update_worker_dependency_call_count_); | |
413 } | |
414 | |
415 TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) { | |
416 // The first rendere host. | |
kinuko
2014/03/11 05:35:41
rendere -> renderer
horo
2014/03/11 06:55:56
Done.
| |
417 scoped_ptr<MockRendererProcessHost> renderer_host1( | |
418 new MockRendererProcessHost( | |
419 100, browser_context_->GetResourceContext(), *partition_.get())); | |
420 scoped_ptr<MockSharedWorkerConnector> connector1( | |
421 new MockSharedWorkerConnector(renderer_host1.get())); | |
422 int worker_route_id; | |
423 int worker_msg_port_route_id1; | |
424 | |
425 // SharedWorkerConnector creates two message ports and sends | |
426 // ViewHostMsg_CreateWorker_Params. | |
427 connector1->Create("http://example.com/w.js", "name", 200, 300); | |
428 EXPECT_EQ(2U, renderer_host1->QueuedMessageCount()); | |
429 // WorkerProcessMsg_CreateWorker shoud be sent to the renderer in which | |
430 // SharedWorker will be created. | |
431 CheckWorkerProcessMsgCreateWorker(renderer_host1->PopMessage(), | |
432 "http://example.com/w.js", | |
433 "name", | |
434 blink::WebContentSecurityPolicyTypeReport, | |
435 &worker_route_id); | |
436 // ViewMsg_WorkerCreated(1) shoud be sent back to SharedWorkerConnector side. | |
437 CheckViewMsgWorkerCreated(renderer_host1->PopMessage(), | |
438 connector1->route_id()); | |
kinuko
2014/03/11 05:35:41
Some of these common code blocks could be probably
horo
2014/03/11 06:55:56
I moved PopMessage() calls to Check**() methods to
| |
439 | |
440 // SharedWorkerConnector side sends MessagePortHostMsg_QueueMessages in | |
441 // WebSharedWorkerProxy::connect. | |
442 connector1->SendQueueMessages(); | |
443 EXPECT_EQ(1, renderer_host1->QueuedMessageCount()); | |
444 // MessagePortMsg_MessagesQueued(2) shoud be sent back to | |
445 // SharedWorkerConnector side. | |
446 CheckMessagePortMsgMessagesQueued( | |
447 renderer_host1->PopMessage(), | |
448 connector1->temporary_remote_port_route_id()); | |
449 | |
450 // When SharedWorkerConnector recieves ViewMsg_WorkerCreated(1), it sends | |
451 // WorkerMsg_Connect wrapped in ViewHostMsg_ForwardToWorker. | |
452 connector1->SendConnect(); | |
453 EXPECT_EQ(1, renderer_host1->QueuedMessageCount()); | |
454 // WorkerMsg_Connect shoud be sent to SharedWorker side. | |
455 CheckWorkerMsgConnect(renderer_host1->PopMessage(), | |
456 worker_route_id, | |
457 connector1->remote_port_id(), | |
458 &worker_msg_port_route_id1); | |
459 | |
460 // When SharedWorkerConnector recieves MessagePortMsg_MessagesQueued(2), it | |
461 // sends MessagePortHostMsg_SendQueuedMessages. | |
462 std::vector<QueuedMessage> empty_messages; | |
463 connector1->SendSendQueuedMessages(empty_messages); | |
464 EXPECT_EQ(0, renderer_host1->QueuedMessageCount()); | |
465 | |
466 // SharedWorker sends WorkerHostMsg_WorkerScriptLoaded in | |
467 // EmbeddedSharedWorkerStub::workerScriptLoaded(). | |
468 EXPECT_TRUE(renderer_host1->OnMessageReceived( | |
469 new WorkerHostMsg_WorkerScriptLoaded(worker_route_id))); | |
470 EXPECT_EQ(0, renderer_host1->QueuedMessageCount()); | |
471 | |
472 // SharedWorker sends WorkerHostMsg_WorkerConnected in | |
473 // EmbeddedSharedWorkerStub::workerScriptLoaded(). | |
474 EXPECT_TRUE( | |
475 renderer_host1->OnMessageReceived(new WorkerHostMsg_WorkerConnected( | |
476 connector1->remote_port_id(), worker_route_id))); | |
477 EXPECT_EQ(1, renderer_host1->QueuedMessageCount()); | |
478 // ViewMsg_WorkerConnected shoud be sent to SharedWorkerConnector side. | |
479 CheckViewMsgWorkerConnected(renderer_host1->PopMessage(), | |
480 connector1->route_id()); | |
481 | |
482 // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage, | |
483 // SharedWorker side shuold recieve MessagePortMsg_Message. | |
484 connector1->SendPostMessage("test1"); | |
485 EXPECT_EQ(1, renderer_host1->QueuedMessageCount()); | |
486 CheckMessagePortMsgMessage( | |
487 renderer_host1->PopMessage(), worker_msg_port_route_id1, "test1"); | |
488 | |
489 // When SharedWorker side sends MessagePortHostMsg_PostMessage, | |
490 // SharedWorkerConnector side shuold recieve MessagePortMsg_Message. | |
491 const std::vector<int> empty_ids; | |
492 EXPECT_TRUE(renderer_host1->OnMessageReceived( | |
493 new MessagePortHostMsg_PostMessage(connector1->remote_port_id(), | |
494 base::ASCIIToUTF16("test2"), | |
495 empty_ids))); | |
496 EXPECT_EQ(1, renderer_host1->QueuedMessageCount()); | |
497 CheckMessagePortMsgMessage( | |
498 renderer_host1->PopMessage(), connector1->local_port_route_id(), "test2"); | |
499 | |
500 // The second rendere host. | |
kinuko
2014/03/11 05:35:41
rendere -> renderer
horo
2014/03/11 06:55:56
Done.
| |
501 scoped_ptr<MockRendererProcessHost> renderer_host2( | |
502 new MockRendererProcessHost( | |
503 400, browser_context_->GetResourceContext(), *partition_.get())); | |
504 scoped_ptr<MockSharedWorkerConnector> connector2( | |
505 new MockSharedWorkerConnector(renderer_host2.get())); | |
506 int worker_msg_port_route_id2; | |
507 | |
508 // UpdateWorkerDependency should not be called yet. | |
509 EXPECT_EQ(0, s_update_worker_dependency_call_count_); | |
510 | |
511 // SharedWorkerConnector creates two message ports and sends | |
512 // ViewHostMsg_CreateWorker_Params. | |
513 connector2->Create("http://example.com/w.js", "name", 500, 600); | |
514 EXPECT_EQ(1U, renderer_host2->QueuedMessageCount()); | |
515 // ViewMsg_WorkerCreated(3) shoud be sent back to SharedWorkerConnector side. | |
516 CheckViewMsgWorkerCreated(renderer_host2->PopMessage(), | |
517 connector2->route_id()); | |
518 | |
519 // UpdateWorkerDependency should be called. | |
520 EXPECT_EQ(1, s_update_worker_dependency_call_count_); | |
521 EXPECT_EQ(1U, s_worker_dependency_added_ids_.size()); | |
522 EXPECT_EQ(100, s_worker_dependency_added_ids_[0]); | |
523 EXPECT_EQ(0U, s_worker_dependency_removed_ids_.size()); | |
524 | |
525 // SharedWorkerConnector side sends MessagePortHostMsg_QueueMessages in | |
526 // WebSharedWorkerProxy::connect. | |
527 connector2->SendQueueMessages(); | |
528 EXPECT_EQ(1, renderer_host2->QueuedMessageCount()); | |
529 // MessagePortMsg_MessagesQueued(4) shoud be sent back to | |
530 // SharedWorkerConnector side. | |
531 CheckMessagePortMsgMessagesQueued( | |
532 renderer_host2->PopMessage(), | |
533 connector2->temporary_remote_port_route_id()); | |
534 | |
535 // When SharedWorkerConnector recieves ViewMsg_WorkerCreated(3), it sends | |
536 // WorkerMsg_Connect wrapped in ViewHostMsg_ForwardToWorker. | |
537 connector2->SendConnect(); | |
538 EXPECT_EQ(1, renderer_host1->QueuedMessageCount()); | |
539 // WorkerMsg_Connect shoud be sent to SharedWorker side. | |
540 CheckWorkerMsgConnect(renderer_host1->PopMessage(), | |
541 worker_route_id, | |
542 connector2->remote_port_id(), | |
543 &worker_msg_port_route_id2); | |
544 | |
545 // When SharedWorkerConnector recieves MessagePortMsg_MessagesQueued(4), it | |
546 // sends MessagePortHostMsg_SendQueuedMessages. | |
547 connector2->SendSendQueuedMessages(empty_messages); | |
548 EXPECT_EQ(0, renderer_host2->QueuedMessageCount()); | |
549 | |
550 // SharedWorker sends WorkerHostMsg_WorkerConnected in | |
551 // EmbeddedSharedWorkerStub::OnConnect(). | |
552 EXPECT_TRUE( | |
553 renderer_host1->OnMessageReceived(new WorkerHostMsg_WorkerConnected( | |
554 connector2->remote_port_id(), worker_route_id))); | |
555 EXPECT_EQ(1, renderer_host2->QueuedMessageCount()); | |
556 // ViewMsg_WorkerConnected shoud be sent to SharedWorkerConnector side. | |
557 CheckViewMsgWorkerConnected(renderer_host2->PopMessage(), | |
558 connector2->route_id()); | |
559 | |
560 // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage, | |
561 // SharedWorker side shuold recieve MessagePortMsg_Message. | |
562 connector2->SendPostMessage("test3"); | |
563 EXPECT_EQ(1, renderer_host1->QueuedMessageCount()); | |
564 CheckMessagePortMsgMessage( | |
565 renderer_host1->PopMessage(), worker_msg_port_route_id2, "test3"); | |
566 | |
567 // When SharedWorker side sends MessagePortHostMsg_PostMessage, | |
568 // SharedWorkerConnector side shuold recieve MessagePortMsg_Message. | |
569 EXPECT_TRUE(renderer_host1->OnMessageReceived( | |
570 new MessagePortHostMsg_PostMessage(connector2->remote_port_id(), | |
571 base::ASCIIToUTF16("test4"), | |
572 empty_ids))); | |
573 EXPECT_EQ(1, renderer_host2->QueuedMessageCount()); | |
574 CheckMessagePortMsgMessage( | |
575 renderer_host2->PopMessage(), connector2->local_port_route_id(), "test4"); | |
576 | |
577 EXPECT_EQ(1, s_update_worker_dependency_call_count_); | |
578 renderer_host2.reset(); | |
579 // UpdateWorkerDependency should be called. | |
580 EXPECT_EQ(2, s_update_worker_dependency_call_count_); | |
581 EXPECT_EQ(0U, s_worker_dependency_added_ids_.size()); | |
582 EXPECT_EQ(1U, s_worker_dependency_removed_ids_.size()); | |
583 EXPECT_EQ(100, s_worker_dependency_removed_ids_[0]); | |
584 } | |
585 | |
586 } // namespace content | |
OLD | NEW |