| 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 |
|---|
Chromium Code Reviews
Issue 195723003:
Revert 256305 "Add SharedWorkerServiceImpl::CheckWorkerDependenc..." (Closed)
Base URL: svn://svn.chromium.org/chrome/