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/service_worker/service_worker_version.h" | 5 #include "content/browser/service_worker/service_worker_version.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 #include <tuple> | 8 #include <tuple> |
9 | 9 |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
(...skipping 20 matching lines...) Expand all Loading... |
31 // IPC messages for testing --------------------------------------------------- | 31 // IPC messages for testing --------------------------------------------------- |
32 | 32 |
33 #define IPC_MESSAGE_IMPL | 33 #define IPC_MESSAGE_IMPL |
34 #include "ipc/ipc_message_macros.h" | 34 #include "ipc/ipc_message_macros.h" |
35 | 35 |
36 #define IPC_MESSAGE_START TestMsgStart | 36 #define IPC_MESSAGE_START TestMsgStart |
37 | 37 |
38 IPC_MESSAGE_CONTROL0(TestMsg_Message) | 38 IPC_MESSAGE_CONTROL0(TestMsg_Message) |
39 IPC_MESSAGE_ROUTED1(TestMsg_MessageFromWorker, int) | 39 IPC_MESSAGE_ROUTED1(TestMsg_MessageFromWorker, int) |
40 | 40 |
41 IPC_MESSAGE_CONTROL1(TestMsg_TestEvent, int) | |
42 IPC_MESSAGE_CONTROL2(TestMsg_TestEvent_Multiple, int, int) | |
43 IPC_MESSAGE_ROUTED2(TestMsg_TestEventResult, int, std::string) | 41 IPC_MESSAGE_ROUTED2(TestMsg_TestEventResult, int, std::string) |
44 | 42 |
45 // --------------------------------------------------------------------------- | 43 // --------------------------------------------------------------------------- |
46 | 44 |
47 namespace content { | 45 namespace content { |
48 | 46 |
49 namespace { | 47 namespace { |
50 | 48 |
51 class MessageReceiver : public EmbeddedWorkerTestHelper { | 49 class MessageReceiver : public EmbeddedWorkerTestHelper { |
52 public: | 50 public: |
53 MessageReceiver() | 51 MessageReceiver() : EmbeddedWorkerTestHelper(base::FilePath()) {} |
54 : EmbeddedWorkerTestHelper(base::FilePath()), | |
55 current_embedded_worker_id_(0) {} | |
56 ~MessageReceiver() override {} | 52 ~MessageReceiver() override {} |
57 | 53 |
58 bool OnMessageToWorker(int thread_id, | |
59 int embedded_worker_id, | |
60 const IPC::Message& message) override { | |
61 if (EmbeddedWorkerTestHelper::OnMessageToWorker( | |
62 thread_id, embedded_worker_id, message)) { | |
63 return true; | |
64 } | |
65 current_embedded_worker_id_ = embedded_worker_id; | |
66 bool handled = true; | |
67 IPC_BEGIN_MESSAGE_MAP(MessageReceiver, message) | |
68 IPC_MESSAGE_HANDLER(TestMsg_Message, OnMessage) | |
69 IPC_MESSAGE_UNHANDLED(handled = false) | |
70 IPC_END_MESSAGE_MAP() | |
71 return handled; | |
72 } | |
73 | |
74 void SimulateSendValueToBrowser(int embedded_worker_id, int value) { | 54 void SimulateSendValueToBrowser(int embedded_worker_id, int value) { |
75 SimulateSend(new TestMsg_MessageFromWorker(embedded_worker_id, value)); | 55 SimulateSend(new TestMsg_MessageFromWorker(embedded_worker_id, value)); |
76 } | 56 } |
77 | 57 |
78 void SimulateSendEventResult(int embedded_worker_id, | 58 void SimulateSendEventResult(int embedded_worker_id, |
79 int request_id, | 59 int request_id, |
80 const std::string& reply) { | 60 const std::string& reply) { |
81 SimulateSend( | 61 SimulateSend( |
82 new TestMsg_TestEventResult(embedded_worker_id, request_id, reply)); | 62 new TestMsg_TestEventResult(embedded_worker_id, request_id, reply)); |
83 } | 63 } |
84 | 64 |
85 private: | 65 private: |
86 void OnMessage() { | 66 void OnMessage() { |
87 // Do nothing. | 67 // Do nothing. |
88 } | 68 } |
89 | 69 |
90 int current_embedded_worker_id_; | |
91 DISALLOW_COPY_AND_ASSIGN(MessageReceiver); | 70 DISALLOW_COPY_AND_ASSIGN(MessageReceiver); |
92 }; | 71 }; |
93 | 72 |
94 void VerifyCalled(bool* called) { | 73 void VerifyCalled(bool* called) { |
95 *called = true; | 74 *called = true; |
96 } | 75 } |
97 | 76 |
98 void ObserveStatusChanges(ServiceWorkerVersion* version, | 77 void ObserveStatusChanges(ServiceWorkerVersion* version, |
99 std::vector<ServiceWorkerVersion::Status>* statuses) { | 78 std::vector<ServiceWorkerVersion::Status>* statuses) { |
100 statuses->push_back(version->status()); | 79 statuses->push_back(version->status()); |
(...skipping 1155 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1256 std::vector<GURL> valid_scopes; | 1235 std::vector<GURL> valid_scopes; |
1257 valid_scopes.push_back(valid_scope_1); | 1236 valid_scopes.push_back(valid_scope_1); |
1258 valid_scopes.push_back(valid_scope_2); | 1237 valid_scopes.push_back(valid_scope_2); |
1259 | 1238 |
1260 std::vector<url::Origin> all_origins; | 1239 std::vector<url::Origin> all_origins; |
1261 url::Origin valid_origin(GURL("https://chromium.org/")); | 1240 url::Origin valid_origin(GURL("https://chromium.org/")); |
1262 std::vector<url::Origin> valid_origin_list(1, valid_origin); | 1241 std::vector<url::Origin> valid_origin_list(1, valid_origin); |
1263 | 1242 |
1264 // Invalid subscope, should kill worker (but in tests will only increase bad | 1243 // Invalid subscope, should kill worker (but in tests will only increase bad |
1265 // message count). | 1244 // message count). |
1266 version_->OnRegisterForeignFetchScopes(std::vector<GURL>(1, GURL()), | 1245 version_->RegisterForeignFetchScopes(std::vector<GURL>(1, GURL()), |
1267 valid_origin_list); | 1246 valid_origin_list); |
1268 base::RunLoop().RunUntilIdle(); | 1247 base::RunLoop().RunUntilIdle(); |
1269 EXPECT_EQ(1, helper_->mock_render_process_host()->bad_msg_count()); | 1248 EXPECT_EQ(1, helper_->mock_render_process_host()->bad_msg_count()); |
1270 EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size()); | 1249 EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size()); |
1271 EXPECT_EQ(0u, version_->foreign_fetch_origins_.size()); | 1250 EXPECT_EQ(0u, version_->foreign_fetch_origins_.size()); |
1272 | 1251 |
1273 // Subscope outside the scope of the worker. | 1252 // Subscope outside the scope of the worker. |
1274 version_->OnRegisterForeignFetchScopes( | 1253 version_->RegisterForeignFetchScopes( |
1275 std::vector<GURL>(1, GURL("http://www.example.com/wrong")), | 1254 std::vector<GURL>(1, GURL("http://www.example.com/wrong")), |
1276 valid_origin_list); | 1255 valid_origin_list); |
1277 base::RunLoop().RunUntilIdle(); | 1256 base::RunLoop().RunUntilIdle(); |
1278 EXPECT_EQ(2, helper_->mock_render_process_host()->bad_msg_count()); | 1257 EXPECT_EQ(2, helper_->mock_render_process_host()->bad_msg_count()); |
1279 EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size()); | 1258 EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size()); |
1280 EXPECT_EQ(0u, version_->foreign_fetch_origins_.size()); | 1259 EXPECT_EQ(0u, version_->foreign_fetch_origins_.size()); |
1281 | 1260 |
1282 // Subscope on wrong origin. | 1261 // Subscope on wrong origin. |
1283 version_->OnRegisterForeignFetchScopes( | 1262 version_->RegisterForeignFetchScopes( |
1284 std::vector<GURL>(1, GURL("http://example.com/test/")), | 1263 std::vector<GURL>(1, GURL("http://example.com/test/")), |
1285 valid_origin_list); | 1264 valid_origin_list); |
1286 base::RunLoop().RunUntilIdle(); | 1265 base::RunLoop().RunUntilIdle(); |
1287 EXPECT_EQ(3, helper_->mock_render_process_host()->bad_msg_count()); | 1266 EXPECT_EQ(3, helper_->mock_render_process_host()->bad_msg_count()); |
1288 EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size()); | 1267 EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size()); |
1289 EXPECT_EQ(0u, version_->foreign_fetch_origins_.size()); | 1268 EXPECT_EQ(0u, version_->foreign_fetch_origins_.size()); |
1290 | 1269 |
1291 // Invalid origin. | 1270 // Invalid origin. |
1292 version_->OnRegisterForeignFetchScopes( | 1271 version_->RegisterForeignFetchScopes( |
1293 valid_scopes, std::vector<url::Origin>(1, url::Origin())); | 1272 valid_scopes, std::vector<url::Origin>(1, url::Origin())); |
1294 base::RunLoop().RunUntilIdle(); | 1273 base::RunLoop().RunUntilIdle(); |
1295 EXPECT_EQ(4, helper_->mock_render_process_host()->bad_msg_count()); | 1274 EXPECT_EQ(4, helper_->mock_render_process_host()->bad_msg_count()); |
1296 EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size()); | 1275 EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size()); |
1297 EXPECT_EQ(0u, version_->foreign_fetch_origins_.size()); | 1276 EXPECT_EQ(0u, version_->foreign_fetch_origins_.size()); |
1298 | 1277 |
1299 // Valid subscope, no origins. | 1278 // Valid subscope, no origins. |
1300 version_->OnRegisterForeignFetchScopes(std::vector<GURL>(1, valid_scope_1), | 1279 version_->RegisterForeignFetchScopes(std::vector<GURL>(1, valid_scope_1), |
1301 all_origins); | 1280 all_origins); |
1302 base::RunLoop().RunUntilIdle(); | 1281 base::RunLoop().RunUntilIdle(); |
1303 EXPECT_EQ(4, helper_->mock_render_process_host()->bad_msg_count()); | 1282 EXPECT_EQ(4, helper_->mock_render_process_host()->bad_msg_count()); |
1304 EXPECT_EQ(1u, version_->foreign_fetch_scopes_.size()); | 1283 EXPECT_EQ(1u, version_->foreign_fetch_scopes_.size()); |
1305 EXPECT_EQ(valid_scope_1, version_->foreign_fetch_scopes_[0]); | 1284 EXPECT_EQ(valid_scope_1, version_->foreign_fetch_scopes_[0]); |
1306 EXPECT_EQ(0u, version_->foreign_fetch_origins_.size()); | 1285 EXPECT_EQ(0u, version_->foreign_fetch_origins_.size()); |
1307 | 1286 |
1308 // Valid subscope, explicit origins. | 1287 // Valid subscope, explicit origins. |
1309 version_->OnRegisterForeignFetchScopes(valid_scopes, valid_origin_list); | 1288 version_->RegisterForeignFetchScopes(valid_scopes, valid_origin_list); |
1310 base::RunLoop().RunUntilIdle(); | 1289 base::RunLoop().RunUntilIdle(); |
1311 EXPECT_EQ(4, helper_->mock_render_process_host()->bad_msg_count()); | 1290 EXPECT_EQ(4, helper_->mock_render_process_host()->bad_msg_count()); |
1312 EXPECT_EQ(2u, version_->foreign_fetch_scopes_.size()); | 1291 EXPECT_EQ(2u, version_->foreign_fetch_scopes_.size()); |
1313 EXPECT_EQ(valid_scope_1, version_->foreign_fetch_scopes_[0]); | 1292 EXPECT_EQ(valid_scope_1, version_->foreign_fetch_scopes_[0]); |
1314 EXPECT_EQ(valid_scope_2, version_->foreign_fetch_scopes_[1]); | 1293 EXPECT_EQ(valid_scope_2, version_->foreign_fetch_scopes_[1]); |
1315 EXPECT_EQ(1u, version_->foreign_fetch_origins_.size()); | 1294 EXPECT_EQ(1u, version_->foreign_fetch_origins_.size()); |
1316 EXPECT_EQ(valid_origin, version_->foreign_fetch_origins_[0]); | 1295 EXPECT_EQ(valid_origin, version_->foreign_fetch_origins_[0]); |
1317 } | 1296 } |
1318 | 1297 |
1319 TEST_F(ServiceWorkerVersionTest, RendererCrashDuringEvent) { | 1298 TEST_F(ServiceWorkerVersionTest, RendererCrashDuringEvent) { |
(...skipping 21 matching lines...) Expand all Loading... |
1341 | 1320 |
1342 // Callback completed. | 1321 // Callback completed. |
1343 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); | 1322 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); |
1344 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); | 1323 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
1345 | 1324 |
1346 // Request already failed, calling finsh should return false. | 1325 // Request already failed, calling finsh should return false. |
1347 EXPECT_FALSE(version_->FinishRequest(request_id, true /* was_handled */, | 1326 EXPECT_FALSE(version_->FinishRequest(request_id, true /* was_handled */, |
1348 base::Time::Now())); | 1327 base::Time::Now())); |
1349 } | 1328 } |
1350 | 1329 |
1351 TEST_F(ServiceWorkerVersionTest, DispatchEvent) { | 1330 TEST_F(ServiceWorkerVersionTest, RegisterRequestCallback) { |
1352 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1331 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1353 | 1332 |
1354 // Activate and start worker. | 1333 // Activate and start worker. |
1355 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1334 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1356 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1335 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1357 CreateReceiverOnCurrentThread(&status)); | 1336 CreateReceiverOnCurrentThread(&status)); |
1358 base::RunLoop().RunUntilIdle(); | 1337 base::RunLoop().RunUntilIdle(); |
1359 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1338 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1360 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); | 1339 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1361 | 1340 |
1362 // Start request and dispatch test event. | 1341 // Start request and dispatch test event. |
1363 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1342 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1364 int request_id = version_->StartRequest( | 1343 int request_id = version_->StartRequest( |
1365 ServiceWorkerMetrics::EventType::SYNC, | 1344 ServiceWorkerMetrics::EventType::SYNC, |
1366 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1345 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1367 int received_request_id = 0; | 1346 int received_request_id = 0; |
1368 std::string received_data; | 1347 std::string received_data; |
1369 version_->RegisterRequestCallback<TestMsg_TestEventResult>( | 1348 version_->RegisterRequestCallback<TestMsg_TestEventResult>( |
1370 request_id, base::Bind(&ReceiveTestEventResult, &received_request_id, | 1349 request_id, base::Bind(&ReceiveTestEventResult, &received_request_id, |
1371 &received_data, runner->QuitClosure())); | 1350 &received_data, runner->QuitClosure())); |
1372 version_->DispatchEvent({request_id}, TestMsg_TestEvent(request_id)); | |
1373 | |
1374 // Verify event got dispatched to worker. | |
1375 base::RunLoop().RunUntilIdle(); | |
1376 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); | |
1377 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); | |
1378 EXPECT_EQ(TestMsg_TestEvent::ID, msg->type()); | |
1379 | 1351 |
1380 // Simulate sending reply to event. | 1352 // Simulate sending reply to event. |
1381 std::string reply("foobar"); | 1353 std::string reply("foobar"); |
1382 helper_->SimulateSendEventResult( | 1354 helper_->SimulateSendEventResult( |
1383 version_->embedded_worker()->embedded_worker_id(), request_id, reply); | 1355 version_->embedded_worker()->embedded_worker_id(), request_id, reply); |
1384 runner->Run(); | 1356 runner->Run(); |
1385 | 1357 |
1386 // Verify message callback got called with correct reply. | 1358 // Verify message callback got called with correct reply. |
1387 EXPECT_EQ(request_id, received_request_id); | 1359 EXPECT_EQ(request_id, received_request_id); |
1388 EXPECT_EQ(reply, received_data); | 1360 EXPECT_EQ(reply, received_data); |
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1469 // StartWorker message will be sent again because OnStopped is called before | 1441 // StartWorker message will be sent again because OnStopped is called before |
1470 // OnStarted. | 1442 // OnStarted. |
1471 version_->StopWorker(CreateReceiverOnCurrentThread(&status2)); | 1443 version_->StopWorker(CreateReceiverOnCurrentThread(&status2)); |
1472 base::RunLoop().RunUntilIdle(); | 1444 base::RunLoop().RunUntilIdle(); |
1473 | 1445 |
1474 EXPECT_EQ(SERVICE_WORKER_OK, status1); | 1446 EXPECT_EQ(SERVICE_WORKER_OK, status1); |
1475 EXPECT_EQ(SERVICE_WORKER_OK, status2); | 1447 EXPECT_EQ(SERVICE_WORKER_OK, status2); |
1476 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); | 1448 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1477 } | 1449 } |
1478 | 1450 |
1479 TEST_F(ServiceWorkerVersionTest, DispatchConcurrentEvent) { | |
1480 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | |
1481 | |
1482 // Activate and start worker. | |
1483 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | |
1484 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | |
1485 CreateReceiverOnCurrentThread(&status)); | |
1486 base::RunLoop().RunUntilIdle(); | |
1487 EXPECT_EQ(SERVICE_WORKER_OK, status); | |
1488 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); | |
1489 | |
1490 // Start first request and dispatch test event. | |
1491 scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner); | |
1492 ServiceWorkerStatusCode status1 = SERVICE_WORKER_OK; // dummy value | |
1493 int request_id1 = version_->StartRequest( | |
1494 ServiceWorkerMetrics::EventType::SYNC, | |
1495 CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure())); | |
1496 int received_request_id1 = 0; | |
1497 std::string received_data1; | |
1498 version_->RegisterRequestCallback<TestMsg_TestEventResult>( | |
1499 request_id1, base::Bind(&ReceiveTestEventResult, &received_request_id1, | |
1500 &received_data1, runner1->QuitClosure())); | |
1501 version_->DispatchEvent({request_id1}, TestMsg_TestEvent(request_id1)); | |
1502 | |
1503 // Start second request and dispatch test event. | |
1504 scoped_refptr<MessageLoopRunner> runner2(new MessageLoopRunner); | |
1505 ServiceWorkerStatusCode status2 = SERVICE_WORKER_OK; // dummy value | |
1506 int request_id2 = version_->StartRequest( | |
1507 ServiceWorkerMetrics::EventType::SYNC, | |
1508 CreateReceiverOnCurrentThread(&status2, runner2->QuitClosure())); | |
1509 int received_request_id2 = 0; | |
1510 std::string received_data2; | |
1511 version_->RegisterRequestCallback<TestMsg_TestEventResult>( | |
1512 request_id2, base::Bind(&ReceiveTestEventResult, &received_request_id2, | |
1513 &received_data2, runner2->QuitClosure())); | |
1514 version_->DispatchEvent({request_id2}, TestMsg_TestEvent(request_id2)); | |
1515 | |
1516 // Make sure events got dispatched in same order. | |
1517 base::RunLoop().RunUntilIdle(); | |
1518 ASSERT_EQ(2u, helper_->inner_ipc_sink()->message_count()); | |
1519 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); | |
1520 ASSERT_EQ(TestMsg_TestEvent::ID, msg->type()); | |
1521 TestMsg_TestEvent::Param params; | |
1522 TestMsg_TestEvent::Read(msg, ¶ms); | |
1523 EXPECT_EQ(request_id1, std::get<0>(params)); | |
1524 msg = helper_->inner_ipc_sink()->GetMessageAt(1); | |
1525 ASSERT_EQ(TestMsg_TestEvent::ID, msg->type()); | |
1526 TestMsg_TestEvent::Read(msg, ¶ms); | |
1527 EXPECT_EQ(request_id2, std::get<0>(params)); | |
1528 | |
1529 // Reply to second event. | |
1530 std::string reply2("foobar"); | |
1531 helper_->SimulateSendEventResult( | |
1532 version_->embedded_worker()->embedded_worker_id(), request_id2, reply2); | |
1533 runner2->Run(); | |
1534 | |
1535 // Verify correct message callback got called with correct reply. | |
1536 EXPECT_EQ(0, received_request_id1); | |
1537 EXPECT_EQ(request_id2, received_request_id2); | |
1538 EXPECT_EQ(reply2, received_data2); | |
1539 EXPECT_EQ(SERVICE_WORKER_OK, status2); | |
1540 EXPECT_TRUE(version_->FinishRequest(request_id2, true /* was_handled */, | |
1541 base::Time::Now())); | |
1542 | |
1543 // Reply to first event. | |
1544 std::string reply1("hello world"); | |
1545 helper_->SimulateSendEventResult( | |
1546 version_->embedded_worker()->embedded_worker_id(), request_id1, reply1); | |
1547 runner1->Run(); | |
1548 | |
1549 // Verify correct response was received. | |
1550 EXPECT_EQ(request_id1, received_request_id1); | |
1551 EXPECT_EQ(request_id2, received_request_id2); | |
1552 EXPECT_EQ(reply1, received_data1); | |
1553 EXPECT_EQ(SERVICE_WORKER_OK, status1); | |
1554 EXPECT_TRUE(version_->FinishRequest(request_id1, true /* was_handled */, | |
1555 base::Time::Now())); | |
1556 } | |
1557 | |
1558 TEST_F(ServiceWorkerVersionTest, DispatchEvent_MultipleResponse) { | |
1559 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | |
1560 | |
1561 // Activate and start worker. | |
1562 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | |
1563 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | |
1564 CreateReceiverOnCurrentThread(&status)); | |
1565 base::RunLoop().RunUntilIdle(); | |
1566 EXPECT_EQ(SERVICE_WORKER_OK, status); | |
1567 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); | |
1568 | |
1569 // Start request and dispatch test event. | |
1570 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | |
1571 int request_id1 = version_->StartRequest( | |
1572 ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, | |
1573 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | |
1574 int request_id2 = version_->StartRequest( | |
1575 ServiceWorkerMetrics::EventType::FETCH_WAITUNTIL, | |
1576 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | |
1577 int received_request_id1 = 0; | |
1578 int received_request_id2 = 0; | |
1579 std::string received_data1; | |
1580 std::string received_data2; | |
1581 version_->RegisterRequestCallback<TestMsg_TestEventResult>( | |
1582 request_id1, base::Bind(&ReceiveTestEventResult, &received_request_id1, | |
1583 &received_data1, runner->QuitClosure())); | |
1584 version_->RegisterRequestCallback<TestMsg_TestEventResult>( | |
1585 request_id2, base::Bind(&ReceiveTestEventResult, &received_request_id2, | |
1586 &received_data2, runner->QuitClosure())); | |
1587 version_->DispatchEvent({request_id1, request_id2}, | |
1588 TestMsg_TestEvent_Multiple(request_id1, request_id2)); | |
1589 | |
1590 // Verify event got dispatched to worker. | |
1591 base::RunLoop().RunUntilIdle(); | |
1592 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); | |
1593 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); | |
1594 EXPECT_EQ(TestMsg_TestEvent_Multiple::ID, msg->type()); | |
1595 | |
1596 // Simulate sending reply to event. | |
1597 std::string reply1("foobar1"); | |
1598 std::string reply2("foobar2"); | |
1599 helper_->SimulateSendEventResult( | |
1600 version_->embedded_worker()->embedded_worker_id(), request_id1, reply1); | |
1601 runner->Run(); | |
1602 | |
1603 // Verify message callback got called with correct reply. | |
1604 EXPECT_EQ(request_id1, received_request_id1); | |
1605 EXPECT_EQ(reply1, received_data1); | |
1606 EXPECT_NE(request_id2, received_request_id2); | |
1607 EXPECT_NE(reply2, received_data2); | |
1608 | |
1609 // Simulate sending reply to event. | |
1610 helper_->SimulateSendEventResult( | |
1611 version_->embedded_worker()->embedded_worker_id(), request_id2, reply2); | |
1612 runner->Run(); | |
1613 | |
1614 // Verify message callback got called with correct reply. | |
1615 EXPECT_EQ(request_id2, received_request_id2); | |
1616 EXPECT_EQ(reply2, received_data2); | |
1617 | |
1618 // Should not have timed out, so error callback should not have been | |
1619 // called and FinishRequest should return true. | |
1620 EXPECT_EQ(SERVICE_WORKER_OK, status); | |
1621 EXPECT_TRUE(version_->FinishRequest(request_id1, true /* was_handled */, | |
1622 base::Time::Now())); | |
1623 EXPECT_TRUE(version_->FinishRequest(request_id2, true /* was_handled */, | |
1624 base::Time::Now())); | |
1625 } | |
1626 | |
1627 } // namespace content | 1451 } // namespace content |
OLD | NEW |