[ServiceWorker] Remove useless ServiceWorkerVersion::DispatchSimpleEvent().

content/browser/service_worker/service_worker_version_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/service_worker/service_worker_version.h"
 
 #include <stdint.h>
 #include <tuple>
 
 #include "base/macros.h"
@@ skipping 23 matching lines @@
 #include "ipc/ipc_message_macros.h"
 
 #define IPC_MESSAGE_START TestMsgStart
 
 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_ROUTED3(TestMsg_TestSimpleEventResult,
-                    int,
-                    blink::WebServiceWorkerEventResult,
-                    base::Time)
-
-IPC_ENUM_TRAITS_MAX_VALUE(blink::WebServiceWorkerEventResult,
-                          blink::WebServiceWorkerEventResultLast)
 
 // ---------------------------------------------------------------------------
 
 namespace content {
 
 namespace {
 
 class MessageReceiver : public EmbeddedWorkerTestHelper {
  public:
   MessageReceiver()
@@ skipping 21 matching lines @@
     SimulateSend(new TestMsg_MessageFromWorker(embedded_worker_id, value));
   }
 
   void SimulateSendEventResult(int embedded_worker_id,
                                int request_id,
                                const std::string& reply) {
     SimulateSend(
         new TestMsg_TestEventResult(embedded_worker_id, request_id, reply));
   }
 
-  void SimulateSendSimpleEventResult(int embedded_worker_id,
-                                     int request_id,
-                                     blink::WebServiceWorkerEventResult reply,
-                                     base::Time dispatch_event_time) {
-    SimulateSend(new TestMsg_TestSimpleEventResult(
-        embedded_worker_id, request_id, reply, dispatch_event_time));
-  }
-
  private:
   void OnMessage() {
     // Do nothing.
   }
 
   int current_embedded_worker_id_;
   DISALLOW_COPY_AND_ASSIGN(MessageReceiver);
 };
 
 void VerifyCalled(bool* called) {
@@ skipping 1440 matching lines @@
 
   // Verify correct response was received.
   EXPECT_EQ(request_id1, received_request_id1);
   EXPECT_EQ(request_id2, received_request_id2);
   EXPECT_EQ(reply1, received_data1);
   EXPECT_EQ(SERVICE_WORKER_OK, status1);
   EXPECT_TRUE(version_->FinishRequest(request_id1, true /* was_handled */,
                                       base::Time::Now()));
 }
 
-TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Completed) {

[falken, 2017/03/30 03:51:39]

I assume this test coverage is elsewhere for the Mojo-based events?

[leonhsl(Using Gerrit), 2017/03/30 07:13:10]

This unit test is for testing SWVersion::DispatchSimpleEvent<>, the goal is to
verify that the mechanism composed by {template DispatchSimpleEvent<>, template
RegisterSimpleRequest<>, function OnSimpleEventResponse()} can work correctly,
now we're removing this mechanism, so I think we can remove all its unit tests
together.

As for the equivalent test for Mojo-based events, I think
service_worker_browsertest.cc is covering some cases, activate and fetch event
etc. I think they're already verifying that the Mojo-based event dispatch
mechanism can work correctly.

-  ServiceWorkerStatusCode status =
-      SERVICE_WORKER_ERROR_MAX_VALUE;  // dummy value
-
-  // Activate and start worker.
-  version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
-  version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC,
-                        CreateReceiverOnCurrentThread(&status));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(SERVICE_WORKER_OK, status);
-  EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status());
-
-  // Start request and dispatch test event.
-  status = SERVICE_WORKER_ERROR_MAX_VALUE;  // dummy value
-  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
-  int request_id = version_->StartRequest(
-      ServiceWorkerMetrics::EventType::SYNC,
-      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
-  version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>(
-      request_id, TestMsg_TestEvent(request_id));
-
-  // 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::ID, msg->type());
-
-  // Simulate sending reply to event.
-  helper_->SimulateSendSimpleEventResult(
-      version_->embedded_worker()->embedded_worker_id(), request_id,
-      blink::WebServiceWorkerEventResultCompleted, base::Time::Now());
-  runner->Run();
-
-  // Verify callback was called with correct status.
-  EXPECT_EQ(SERVICE_WORKER_OK, status);
-}
-
-TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Rejected) {
-  ServiceWorkerStatusCode status =
-      SERVICE_WORKER_ERROR_MAX_VALUE;  // dummy value
-
-  // Activate and start worker.
-  version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
-  version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC,
-                        CreateReceiverOnCurrentThread(&status));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(SERVICE_WORKER_OK, status);
-  EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status());
-
-  // Start request and dispatch test event.
-  status = SERVICE_WORKER_ERROR_MAX_VALUE;  // dummy value
-  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
-  int request_id = version_->StartRequest(
-      ServiceWorkerMetrics::EventType::SYNC,
-      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
-  version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>(
-      request_id, TestMsg_TestEvent(request_id));
-
-  // 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::ID, msg->type());
-
-  // Simulate sending reply to event.
-  helper_->SimulateSendSimpleEventResult(
-      version_->embedded_worker()->embedded_worker_id(), request_id,
-      blink::WebServiceWorkerEventResultRejected, base::Time::Now());
-  runner->Run();
-
-  // Verify callback was called with correct status.
-  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());
@@ skipping 50 matching lines @@
   // 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 /* was_handled */,
                                       base::Time::Now()));
   EXPECT_TRUE(version_->FinishRequest(request_id2, true /* was_handled */,
                                       base::Time::Now()));
 }
 
 }  // namespace content