ServiceWorker: Keep the worker alive until FetchEvent.waitUntil settles

content/browser/service_worker/service_worker_version_unittest.cc

Index: content/browser/service_worker/service_worker_version_unittest.cc
diff --git a/content/browser/service_worker/service_worker_version_unittest.cc b/content/browser/service_worker/service_worker_version_unittest.cc
index dbdf4c8057100b5a776b9e622cc65c057e23382b..a3180d8199717f6a81d945b616c597f4edb74dba 100644
--- a/content/browser/service_worker/service_worker_version_unittest.cc
+++ b/content/browser/service_worker/service_worker_version_unittest.cc
@@ -35,6 +35,7 @@ IPC_MESSAGE_CONTROL0(TestMsg_Message)
 IPC_MESSAGE_ROUTED1(TestMsg_MessageFromWorker, int)
 
 IPC_MESSAGE_CONTROL1(TestMsg_TestEvent, int)
+IPC_MESSAGE_CONTROL2(TestMsg_TestEvent_Multiple, int, int)
 IPC_MESSAGE_ROUTED2(TestMsg_TestEventResult, int, std::string)
 IPC_MESSAGE_ROUTED2(TestMsg_TestSimpleEventResult,
                     int,
@@ -1240,10 +1241,10 @@ TEST_F(ServiceWorkerVersionTest, DispatchEvent) {
       CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
   int received_request_id = 0;
   std::string received_data;
-  version_->DispatchEvent<TestMsg_TestEventResult>(
-      request_id, TestMsg_TestEvent(request_id),
-      base::Bind(&ReceiveTestEventResult, &received_request_id, &received_data,
-                 runner->QuitClosure()));
+  version_->RegisterRequestCallback<TestMsg_TestEventResult>(
+      request_id, base::Bind(&ReceiveTestEventResult, &received_request_id,
+                             &received_data, runner->QuitClosure()));
+  version_->DispatchEvent({request_id}, TestMsg_TestEvent(request_id));
 
   // Verify event got dispatched to worker.
   base::RunLoop().RunUntilIdle();
@@ -1345,10 +1346,10 @@ TEST_F(ServiceWorkerVersionTest, DispatchConcurrentEvent) {
       CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure()));
   int received_request_id1 = 0;
   std::string received_data1;
-  version_->DispatchEvent<TestMsg_TestEventResult>(
-      request_id1, TestMsg_TestEvent(request_id1),
-      base::Bind(&ReceiveTestEventResult, &received_request_id1,
-                 &received_data1, runner1->QuitClosure()));
+  version_->RegisterRequestCallback<TestMsg_TestEventResult>(
+      request_id1, base::Bind(&ReceiveTestEventResult, &received_request_id1,
+                              &received_data1, runner1->QuitClosure()));
+  version_->DispatchEvent({request_id1}, TestMsg_TestEvent(request_id1));
 
   // Start second request and dispatch test event.
   scoped_refptr<MessageLoopRunner> runner2(new MessageLoopRunner);
@@ -1358,10 +1359,10 @@ TEST_F(ServiceWorkerVersionTest, DispatchConcurrentEvent) {
       CreateReceiverOnCurrentThread(&status2, runner2->QuitClosure()));
   int received_request_id2 = 0;
   std::string received_data2;
-  version_->DispatchEvent<TestMsg_TestEventResult>(
-      request_id2, TestMsg_TestEvent(request_id2),
-      base::Bind(&ReceiveTestEventResult, &received_request_id2,
-                 &received_data2, runner2->QuitClosure()));
+  version_->RegisterRequestCallback<TestMsg_TestEventResult>(
+      request_id2, base::Bind(&ReceiveTestEventResult, &received_request_id2,
+                              &received_data2, runner2->QuitClosure()));
+  version_->DispatchEvent({request_id2}, TestMsg_TestEvent(request_id2));
 
   // Make sure events got dispatched in same order.
   base::RunLoop().RunUntilIdle();
@@ -1477,4 +1478,71 @@ TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Rejected) {
   EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status);
 }
 
+TEST_F(ServiceWorkerVersionTest, DispatchEvent_MultipleResponse) {
+  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE;
+
+  // Activate and start worker.
+  version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
+  version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN,
+                        CreateReceiverOnCurrentThread(&status));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(SERVICE_WORKER_OK, status);
+  EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status());
+
+  // Start request and dispatch test event.
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
+  int request_id1 = version_->StartRequest(
+      ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME,
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
+  int request_id2 = version_->StartRequest(
+      ServiceWorkerMetrics::EventType::FETCH_WAITUNTIL,
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
+  int received_request_id1 = 0;
+  int received_request_id2 = 0;
+  std::string received_data1;
+  std::string received_data2;
+  version_->RegisterRequestCallback<TestMsg_TestEventResult>(
+      request_id1, base::Bind(&ReceiveTestEventResult, &received_request_id1,
+                              &received_data1, runner->QuitClosure()));
+  version_->RegisterRequestCallback<TestMsg_TestEventResult>(
+      request_id2, base::Bind(&ReceiveTestEventResult, &received_request_id2,
+                              &received_data2, runner->QuitClosure()));
+  version_->DispatchEvent({request_id1, request_id2},
+                          TestMsg_TestEvent_Multiple(request_id1, request_id2));
+
+  // Verify event got dispatched to worker.
+  base::RunLoop().RunUntilIdle();
+  ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count());
+  const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0);
+  EXPECT_EQ(TestMsg_TestEvent_Multiple::ID, msg->type());
+
+  // Simulate sending reply to event.
+  std::string reply1("foobar1");
+  std::string reply2("foobar2");
+  helper_->SimulateSendEventResult(
+      version_->embedded_worker()->embedded_worker_id(), request_id1, reply1);
+  runner->Run();
+
+  // Verify message callback got called with correct reply.
+  EXPECT_EQ(request_id1, received_request_id1);
+  EXPECT_EQ(reply1, received_data1);
+  EXPECT_NE(request_id2, received_request_id2);
+  EXPECT_NE(reply2, received_data2);
+
+  // Simulate sending reply to event.
+  helper_->SimulateSendEventResult(
+      version_->embedded_worker()->embedded_worker_id(), request_id2, reply2);
+  runner->Run();
+
+  // Verify message callback got called with correct reply.
+  EXPECT_EQ(request_id2, received_request_id2);
+  EXPECT_EQ(reply2, received_data2);
+
+  // Should not have timed out, so error callback should not have been
+  // called and FinishRequest should return true.
+  EXPECT_EQ(SERVICE_WORKER_OK, status);
+  EXPECT_TRUE(version_->FinishRequest(request_id1, true));
+  EXPECT_TRUE(version_->FinishRequest(request_id2, true));
+}
+
 }  // namespace content