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_id, |
| 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_id, |
| 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 class MockSharedWorkerConnector { |
| 168 public: |
| 169 MockSharedWorkerConnector(MockRendererProcessHost* renderer_host) |
| 170 : renderer_host_(renderer_host), |
| 171 temporary_remote_port_route_id_(0), |
| 172 remote_port_id_(0), |
| 173 local_port_route_id_(0), |
| 174 local_port_id_(0), |
| 175 route_id_(0) {} |
| 176 void Create(const std::string& url, |
| 177 const std::string& name, |
| 178 unsigned long long document_id, |
| 179 int render_frame_route_id) { |
| 180 CreateMessagePortPair(renderer_host_, |
| 181 &temporary_remote_port_route_id_, |
| 182 &remote_port_id_, |
| 183 &local_port_route_id_, |
| 184 &local_port_id_); |
| 185 PostCreateWorker(renderer_host_, |
| 186 url, |
| 187 name, |
| 188 document_id, |
| 189 render_frame_route_id, |
| 190 &route_id_); |
| 191 } |
| 192 void SendQueueMessages() { |
| 193 EXPECT_TRUE(renderer_host_->OnMessageReceived( |
| 194 new MessagePortHostMsg_QueueMessages(remote_port_id_))); |
| 195 } |
| 196 void SendPostMessage(std::string data) { |
| 197 const std::vector<int> empty_ids; |
| 198 EXPECT_TRUE( |
| 199 renderer_host_->OnMessageReceived(new MessagePortHostMsg_PostMessage( |
| 200 local_port_id_, base::ASCIIToUTF16(data), empty_ids))); |
| 201 } |
| 202 void SendConnect() { |
| 203 EXPECT_TRUE( |
| 204 renderer_host_->OnMessageReceived(new ViewHostMsg_ForwardToWorker( |
| 205 WorkerMsg_Connect(route_id_, remote_port_id_, MSG_ROUTING_NONE)))); |
| 206 } |
| 207 void SendSendQueuedMessages( |
| 208 const std::vector<QueuedMessage>& queued_messages) { |
| 209 EXPECT_TRUE(renderer_host_->OnMessageReceived( |
| 210 new MessagePortHostMsg_SendQueuedMessages(remote_port_id_, |
| 211 queued_messages))); |
| 212 } |
| 213 int temporary_remote_port_route_id() { |
| 214 return temporary_remote_port_route_id_; |
| 215 } |
| 216 int remote_port_id() { return remote_port_id_; } |
| 217 int local_port_route_id() { return local_port_route_id_; } |
| 218 int local_port_id() { return local_port_id_; } |
| 219 int route_id() { return route_id_; } |
| 220 |
| 221 private: |
| 222 MockRendererProcessHost* renderer_host_; |
| 223 int temporary_remote_port_route_id_; |
| 224 int remote_port_id_; |
| 225 int local_port_route_id_; |
| 226 int local_port_id_; |
| 227 int route_id_; |
| 228 }; |
| 229 |
| 230 void CheckWorkerProcessMsgCreateWorker( |
| 231 MockRendererProcessHost* renderer_host, |
| 232 const std::string& expected_url, |
| 233 const std::string& expected_name, |
| 234 blink::WebContentSecurityPolicyType expected_security_policy_type, |
| 235 int* route_id) { |
| 236 scoped_ptr<IPC::Message> msg(renderer_host->PopMessage()); |
| 237 EXPECT_EQ(WorkerProcessMsg_CreateWorker::ID, msg->type()); |
| 238 Tuple1<WorkerProcessMsg_CreateWorker_Params> param; |
| 239 EXPECT_TRUE(WorkerProcessMsg_CreateWorker::Read(msg.get(), ¶m)); |
| 240 EXPECT_EQ(GURL(expected_url), param.a.url); |
| 241 EXPECT_EQ(base::ASCIIToUTF16(expected_name), param.a.name); |
| 242 EXPECT_EQ(expected_security_policy_type, param.a.security_policy_type); |
| 243 *route_id = param.a.route_id; |
| 244 } |
| 245 |
| 246 void CheckViewMsgWorkerCreated(MockRendererProcessHost* renderer_host, |
| 247 MockSharedWorkerConnector* connector) { |
| 248 scoped_ptr<IPC::Message> msg(renderer_host->PopMessage()); |
| 249 EXPECT_EQ(ViewMsg_WorkerCreated::ID, msg->type()); |
| 250 EXPECT_EQ(connector->route_id(), msg->routing_id()); |
| 251 } |
| 252 |
| 253 void CheckMessagePortMsgMessagesQueued(MockRendererProcessHost* renderer_host, |
| 254 MockSharedWorkerConnector* connector) { |
| 255 scoped_ptr<IPC::Message> msg(renderer_host->PopMessage()); |
| 256 EXPECT_EQ(MessagePortMsg_MessagesQueued::ID, msg->type()); |
| 257 EXPECT_EQ(connector->temporary_remote_port_route_id(), msg->routing_id()); |
| 258 } |
| 259 |
| 260 void CheckWorkerMsgConnect(MockRendererProcessHost* renderer_host, |
| 261 int expected_msg_route_id, |
| 262 int expected_sent_message_port_id, |
| 263 int* routing_id) { |
| 264 scoped_ptr<IPC::Message> msg(renderer_host->PopMessage()); |
| 265 EXPECT_EQ(WorkerMsg_Connect::ID, msg->type()); |
| 266 EXPECT_EQ(expected_msg_route_id, msg->routing_id()); |
| 267 int port_id; |
| 268 EXPECT_TRUE(WorkerMsg_Connect::Read(msg.get(), &port_id, routing_id)); |
| 269 EXPECT_EQ(expected_sent_message_port_id, port_id); |
| 270 } |
| 271 |
| 272 void CheckMessagePortMsgMessage(MockRendererProcessHost* renderer_host, |
| 273 int expected_msg_route_id, |
| 274 std::string expected_data) { |
| 275 scoped_ptr<IPC::Message> msg(renderer_host->PopMessage()); |
| 276 EXPECT_EQ(MessagePortMsg_Message::ID, msg->type()); |
| 277 EXPECT_EQ(expected_msg_route_id, msg->routing_id()); |
| 278 base::string16 data; |
| 279 std::vector<int> sent_message_port_ids; |
| 280 std::vector<int> new_routing_ids; |
| 281 EXPECT_TRUE(MessagePortMsg_Message::Read( |
| 282 msg.get(), &data, &sent_message_port_ids, &new_routing_ids)); |
| 283 EXPECT_EQ(base::ASCIIToUTF16(expected_data), data); |
| 284 } |
| 285 |
| 286 void CheckViewMsgWorkerConnected(MockRendererProcessHost* renderer_host, |
| 287 MockSharedWorkerConnector* connector) { |
| 288 scoped_ptr<IPC::Message> msg(renderer_host->PopMessage()); |
| 289 EXPECT_EQ(ViewMsg_WorkerConnected::ID, msg->type()); |
| 290 EXPECT_EQ(connector->route_id(), msg->routing_id()); |
| 291 } |
| 292 |
| 293 } // namespace |
| 294 |
| 295 class SharedWorkerServiceImplTest : public testing::Test { |
| 296 protected: |
| 297 SharedWorkerServiceImplTest() |
| 298 : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP), |
| 299 browser_context_(new TestBrowserContext()), |
| 300 partition_( |
| 301 new WorkerStoragePartition(browser_context_->GetRequestContext(), |
| 302 NULL, |
| 303 NULL, |
| 304 NULL, |
| 305 NULL, |
| 306 NULL, |
| 307 NULL)) { |
| 308 SharedWorkerServiceImpl::GetInstance() |
| 309 ->ChangeUpdateWorkerDependencyFuncForTesting( |
| 310 &SharedWorkerServiceImplTest::MockUpdateWorkerDependency); |
| 311 } |
| 312 |
| 313 virtual void SetUp() OVERRIDE {} |
| 314 virtual void TearDown() OVERRIDE { |
| 315 s_update_worker_dependency_call_count_ = 0; |
| 316 s_worker_dependency_added_ids_.clear(); |
| 317 s_worker_dependency_removed_ids_.clear(); |
| 318 SharedWorkerServiceImpl::GetInstance()->ResetForTesting(); |
| 319 } |
| 320 static void MockUpdateWorkerDependency(const std::vector<int>& added_ids, |
| 321 const std::vector<int>& removed_ids) { |
| 322 ++s_update_worker_dependency_call_count_; |
| 323 s_worker_dependency_added_ids_ = added_ids; |
| 324 s_worker_dependency_removed_ids_ = removed_ids; |
| 325 } |
| 326 |
| 327 TestBrowserThreadBundle browser_thread_bundle_; |
| 328 scoped_ptr<TestBrowserContext> browser_context_; |
| 329 scoped_ptr<WorkerStoragePartition> partition_; |
| 330 static int s_update_worker_dependency_call_count_; |
| 331 static std::vector<int> s_worker_dependency_added_ids_; |
| 332 static std::vector<int> s_worker_dependency_removed_ids_; |
| 333 DISALLOW_COPY_AND_ASSIGN(SharedWorkerServiceImplTest); |
| 334 }; |
| 335 |
| 336 // static |
| 337 int SharedWorkerServiceImplTest::s_update_worker_dependency_call_count_; |
| 338 std::vector<int> SharedWorkerServiceImplTest::s_worker_dependency_added_ids_; |
| 339 std::vector<int> SharedWorkerServiceImplTest::s_worker_dependency_removed_ids_; |
| 340 |
| 341 TEST_F(SharedWorkerServiceImplTest, BasicTest) { |
| 342 scoped_ptr<MockRendererProcessHost> renderer_host(new MockRendererProcessHost( |
| 343 100, browser_context_->GetResourceContext(), *partition_.get())); |
| 344 scoped_ptr<MockSharedWorkerConnector> connector( |
| 345 new MockSharedWorkerConnector(renderer_host.get())); |
| 346 int worker_route_id; |
| 347 int worker_msg_port_route_id; |
| 348 |
| 349 // SharedWorkerConnector creates two message ports and sends |
| 350 // ViewHostMsg_CreateWorker. |
| 351 connector->Create("http://example.com/w.js", "name", 200, 300); |
| 352 EXPECT_EQ(2U, renderer_host->QueuedMessageCount()); |
| 353 // WorkerProcessMsg_CreateWorker should be sent to the renderer in which |
| 354 // SharedWorker will be created. |
| 355 CheckWorkerProcessMsgCreateWorker(renderer_host.get(), |
| 356 "http://example.com/w.js", |
| 357 "name", |
| 358 blink::WebContentSecurityPolicyTypeReport, |
| 359 &worker_route_id); |
| 360 // ViewMsg_WorkerCreated(1) should be sent back to SharedWorkerConnector side. |
| 361 CheckViewMsgWorkerCreated(renderer_host.get(), connector.get()); |
| 362 |
| 363 // SharedWorkerConnector side sends MessagePortHostMsg_QueueMessages in |
| 364 // WebSharedWorkerProxy::connect. |
| 365 connector->SendQueueMessages(); |
| 366 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); |
| 367 // MessagePortMsg_MessagesQueued(2) should be sent back to |
| 368 // SharedWorkerConnector side. |
| 369 CheckMessagePortMsgMessagesQueued(renderer_host.get(), connector.get()); |
| 370 |
| 371 // When SharedWorkerConnector receives ViewMsg_WorkerCreated(1), it sends |
| 372 // WorkerMsg_Connect wrapped in ViewHostMsg_ForwardToWorker. |
| 373 connector->SendConnect(); |
| 374 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); |
| 375 // WorkerMsg_Connect should be sent to SharedWorker side. |
| 376 CheckWorkerMsgConnect(renderer_host.get(), |
| 377 worker_route_id, |
| 378 connector->remote_port_id(), |
| 379 &worker_msg_port_route_id); |
| 380 |
| 381 // When SharedWorkerConnector receives MessagePortMsg_MessagesQueued(2), it |
| 382 // sends MessagePortHostMsg_SendQueuedMessages. |
| 383 std::vector<QueuedMessage> empty_messages; |
| 384 connector->SendSendQueuedMessages(empty_messages); |
| 385 EXPECT_EQ(0U, renderer_host->QueuedMessageCount()); |
| 386 |
| 387 // SharedWorker sends WorkerHostMsg_WorkerScriptLoaded in |
| 388 // EmbeddedSharedWorkerStub::workerScriptLoaded(). |
| 389 EXPECT_TRUE(renderer_host->OnMessageReceived( |
| 390 new WorkerHostMsg_WorkerScriptLoaded(worker_route_id))); |
| 391 EXPECT_EQ(0U, renderer_host->QueuedMessageCount()); |
| 392 |
| 393 // SharedWorker sends WorkerHostMsg_WorkerConnected in |
| 394 // EmbeddedSharedWorkerStub::workerScriptLoaded(). |
| 395 EXPECT_TRUE( |
| 396 renderer_host->OnMessageReceived(new WorkerHostMsg_WorkerConnected( |
| 397 connector->remote_port_id(), worker_route_id))); |
| 398 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); |
| 399 // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side. |
| 400 CheckViewMsgWorkerConnected(renderer_host.get(), connector.get()); |
| 401 |
| 402 // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage, |
| 403 // SharedWorker side shuold receive MessagePortMsg_Message. |
| 404 connector->SendPostMessage("test1"); |
| 405 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); |
| 406 CheckMessagePortMsgMessage( |
| 407 renderer_host.get(), worker_msg_port_route_id, "test1"); |
| 408 |
| 409 // When SharedWorker side sends MessagePortHostMsg_PostMessage, |
| 410 // SharedWorkerConnector side shuold receive MessagePortMsg_Message. |
| 411 const std::vector<int> empty_ids; |
| 412 EXPECT_TRUE(renderer_host->OnMessageReceived( |
| 413 new MessagePortHostMsg_PostMessage(connector->remote_port_id(), |
| 414 base::ASCIIToUTF16("test2"), |
| 415 empty_ids))); |
| 416 EXPECT_EQ(1U, renderer_host->QueuedMessageCount()); |
| 417 CheckMessagePortMsgMessage( |
| 418 renderer_host.get(), connector->local_port_route_id(), "test2"); |
| 419 |
| 420 // UpdateWorkerDependency should not be called. |
| 421 EXPECT_EQ(0, s_update_worker_dependency_call_count_); |
| 422 } |
| 423 |
| 424 TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) { |
| 425 // The first renderer host. |
| 426 scoped_ptr<MockRendererProcessHost> renderer_host1( |
| 427 new MockRendererProcessHost( |
| 428 100, browser_context_->GetResourceContext(), *partition_.get())); |
| 429 scoped_ptr<MockSharedWorkerConnector> connector1( |
| 430 new MockSharedWorkerConnector(renderer_host1.get())); |
| 431 int worker_route_id; |
| 432 int worker_msg_port_route_id1; |
| 433 |
| 434 // SharedWorkerConnector creates two message ports and sends |
| 435 // ViewHostMsg_CreateWorker. |
| 436 connector1->Create("http://example.com/w.js", "name", 200, 300); |
| 437 EXPECT_EQ(2U, renderer_host1->QueuedMessageCount()); |
| 438 // WorkerProcessMsg_CreateWorker should be sent to the renderer in which |
| 439 // SharedWorker will be created. |
| 440 CheckWorkerProcessMsgCreateWorker(renderer_host1.get(), |
| 441 "http://example.com/w.js", |
| 442 "name", |
| 443 blink::WebContentSecurityPolicyTypeReport, |
| 444 &worker_route_id); |
| 445 // ViewMsg_WorkerCreated(1) should be sent back to SharedWorkerConnector side. |
| 446 CheckViewMsgWorkerCreated(renderer_host1.get(), connector1.get()); |
| 447 |
| 448 // SharedWorkerConnector side sends MessagePortHostMsg_QueueMessages in |
| 449 // WebSharedWorkerProxy::connect. |
| 450 connector1->SendQueueMessages(); |
| 451 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); |
| 452 // MessagePortMsg_MessagesQueued(2) should be sent back to |
| 453 // SharedWorkerConnector side. |
| 454 CheckMessagePortMsgMessagesQueued(renderer_host1.get(), connector1.get()); |
| 455 |
| 456 // When SharedWorkerConnector receives ViewMsg_WorkerCreated(1), it sends |
| 457 // WorkerMsg_Connect wrapped in ViewHostMsg_ForwardToWorker. |
| 458 connector1->SendConnect(); |
| 459 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); |
| 460 // WorkerMsg_Connect should be sent to SharedWorker side. |
| 461 CheckWorkerMsgConnect(renderer_host1.get(), |
| 462 worker_route_id, |
| 463 connector1->remote_port_id(), |
| 464 &worker_msg_port_route_id1); |
| 465 |
| 466 // When SharedWorkerConnector receives MessagePortMsg_MessagesQueued(2), it |
| 467 // sends MessagePortHostMsg_SendQueuedMessages. |
| 468 std::vector<QueuedMessage> empty_messages; |
| 469 connector1->SendSendQueuedMessages(empty_messages); |
| 470 EXPECT_EQ(0U, renderer_host1->QueuedMessageCount()); |
| 471 |
| 472 // SharedWorker sends WorkerHostMsg_WorkerScriptLoaded in |
| 473 // EmbeddedSharedWorkerStub::workerScriptLoaded(). |
| 474 EXPECT_TRUE(renderer_host1->OnMessageReceived( |
| 475 new WorkerHostMsg_WorkerScriptLoaded(worker_route_id))); |
| 476 EXPECT_EQ(0U, renderer_host1->QueuedMessageCount()); |
| 477 |
| 478 // SharedWorker sends WorkerHostMsg_WorkerConnected in |
| 479 // EmbeddedSharedWorkerStub::workerScriptLoaded(). |
| 480 EXPECT_TRUE( |
| 481 renderer_host1->OnMessageReceived(new WorkerHostMsg_WorkerConnected( |
| 482 connector1->remote_port_id(), worker_route_id))); |
| 483 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); |
| 484 // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side. |
| 485 CheckViewMsgWorkerConnected(renderer_host1.get(), connector1.get()); |
| 486 |
| 487 // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage, |
| 488 // SharedWorker side shuold receive MessagePortMsg_Message. |
| 489 connector1->SendPostMessage("test1"); |
| 490 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); |
| 491 CheckMessagePortMsgMessage( |
| 492 renderer_host1.get(), worker_msg_port_route_id1, "test1"); |
| 493 |
| 494 // When SharedWorker side sends MessagePortHostMsg_PostMessage, |
| 495 // SharedWorkerConnector side shuold receive MessagePortMsg_Message. |
| 496 const std::vector<int> empty_ids; |
| 497 EXPECT_TRUE(renderer_host1->OnMessageReceived( |
| 498 new MessagePortHostMsg_PostMessage(connector1->remote_port_id(), |
| 499 base::ASCIIToUTF16("test2"), |
| 500 empty_ids))); |
| 501 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); |
| 502 CheckMessagePortMsgMessage( |
| 503 renderer_host1.get(), connector1->local_port_route_id(), "test2"); |
| 504 |
| 505 // The second renderer host. |
| 506 scoped_ptr<MockRendererProcessHost> renderer_host2( |
| 507 new MockRendererProcessHost( |
| 508 400, browser_context_->GetResourceContext(), *partition_.get())); |
| 509 scoped_ptr<MockSharedWorkerConnector> connector2( |
| 510 new MockSharedWorkerConnector(renderer_host2.get())); |
| 511 int worker_msg_port_route_id2; |
| 512 |
| 513 // UpdateWorkerDependency should not be called yet. |
| 514 EXPECT_EQ(0, s_update_worker_dependency_call_count_); |
| 515 |
| 516 // SharedWorkerConnector creates two message ports and sends |
| 517 // ViewHostMsg_CreateWorker. |
| 518 connector2->Create("http://example.com/w.js", "name", 500, 600); |
| 519 EXPECT_EQ(1U, renderer_host2->QueuedMessageCount()); |
| 520 // ViewMsg_WorkerCreated(3) should be sent back to SharedWorkerConnector side. |
| 521 CheckViewMsgWorkerCreated(renderer_host2.get(), connector2.get()); |
| 522 |
| 523 // UpdateWorkerDependency should be called. |
| 524 EXPECT_EQ(1, s_update_worker_dependency_call_count_); |
| 525 EXPECT_EQ(1U, s_worker_dependency_added_ids_.size()); |
| 526 EXPECT_EQ(100, s_worker_dependency_added_ids_[0]); |
| 527 EXPECT_EQ(0U, s_worker_dependency_removed_ids_.size()); |
| 528 |
| 529 // SharedWorkerConnector side sends MessagePortHostMsg_QueueMessages in |
| 530 // WebSharedWorkerProxy::connect. |
| 531 connector2->SendQueueMessages(); |
| 532 EXPECT_EQ(1U, renderer_host2->QueuedMessageCount()); |
| 533 // MessagePortMsg_MessagesQueued(4) should be sent back to |
| 534 // SharedWorkerConnector side. |
| 535 CheckMessagePortMsgMessagesQueued(renderer_host2.get(), connector2.get()); |
| 536 |
| 537 // When SharedWorkerConnector receives ViewMsg_WorkerCreated(3), it sends |
| 538 // WorkerMsg_Connect wrapped in ViewHostMsg_ForwardToWorker. |
| 539 connector2->SendConnect(); |
| 540 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); |
| 541 // WorkerMsg_Connect should be sent to SharedWorker side. |
| 542 CheckWorkerMsgConnect(renderer_host1.get(), |
| 543 worker_route_id, |
| 544 connector2->remote_port_id(), |
| 545 &worker_msg_port_route_id2); |
| 546 |
| 547 // When SharedWorkerConnector receives MessagePortMsg_MessagesQueued(4), it |
| 548 // sends MessagePortHostMsg_SendQueuedMessages. |
| 549 connector2->SendSendQueuedMessages(empty_messages); |
| 550 EXPECT_EQ(0U, renderer_host2->QueuedMessageCount()); |
| 551 |
| 552 // SharedWorker sends WorkerHostMsg_WorkerConnected in |
| 553 // EmbeddedSharedWorkerStub::OnConnect(). |
| 554 EXPECT_TRUE( |
| 555 renderer_host1->OnMessageReceived(new WorkerHostMsg_WorkerConnected( |
| 556 connector2->remote_port_id(), worker_route_id))); |
| 557 EXPECT_EQ(1U, renderer_host2->QueuedMessageCount()); |
| 558 // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side. |
| 559 CheckViewMsgWorkerConnected(renderer_host2.get(), connector2.get()); |
| 560 |
| 561 // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage, |
| 562 // SharedWorker side shuold receive MessagePortMsg_Message. |
| 563 connector2->SendPostMessage("test3"); |
| 564 EXPECT_EQ(1U, renderer_host1->QueuedMessageCount()); |
| 565 CheckMessagePortMsgMessage( |
| 566 renderer_host1.get(), worker_msg_port_route_id2, "test3"); |
| 567 |
| 568 // When SharedWorker side sends MessagePortHostMsg_PostMessage, |
| 569 // SharedWorkerConnector side shuold receive MessagePortMsg_Message. |
| 570 EXPECT_TRUE(renderer_host1->OnMessageReceived( |
| 571 new MessagePortHostMsg_PostMessage(connector2->remote_port_id(), |
| 572 base::ASCIIToUTF16("test4"), |
| 573 empty_ids))); |
| 574 EXPECT_EQ(1U, renderer_host2->QueuedMessageCount()); |
| 575 CheckMessagePortMsgMessage( |
| 576 renderer_host2.get(), connector2->local_port_route_id(), "test4"); |
| 577 |
| 578 EXPECT_EQ(1, s_update_worker_dependency_call_count_); |
| 579 renderer_host2.reset(); |
| 580 // UpdateWorkerDependency should be called. |
| 581 EXPECT_EQ(2, s_update_worker_dependency_call_count_); |
| 582 EXPECT_EQ(0U, s_worker_dependency_added_ids_.size()); |
| 583 EXPECT_EQ(1U, s_worker_dependency_removed_ids_.size()); |
| 584 EXPECT_EQ(100, s_worker_dependency_removed_ids_[0]); |
| 585 } |
| 586 |
| 587 } // namespace content |
OLD | NEW |