[ServiceWorker] Mojofy InstallEvent of Service Worker

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 21 matching lines @@
 
 #define IPC_MESSAGE_IMPL
 #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)

[leonhsl(Using Gerrit), 2017/04/25 06:53:27]

Remove useless messages.

[xiaofengzhang, 2017/04/25 07:18:15]

Acknowledged.

 IPC_MESSAGE_ROUTED2(TestMsg_TestEventResult, int, std::string)
 
 // ---------------------------------------------------------------------------
 
 namespace content {
 
 namespace {
 
 class MessageReceiver : public EmbeddedWorkerTestHelper {
  public:
-  MessageReceiver()
-      : EmbeddedWorkerTestHelper(base::FilePath()),
-        current_embedded_worker_id_(0) {}
+  MessageReceiver() : EmbeddedWorkerTestHelper(base::FilePath()) {}
   ~MessageReceiver() override {}
 
-  bool OnMessageToWorker(int thread_id,
-                         int embedded_worker_id,
-                         const IPC::Message& message) override {
-    if (EmbeddedWorkerTestHelper::OnMessageToWorker(
-            thread_id, embedded_worker_id, message)) {
-      return true;
-    }
-    current_embedded_worker_id_ = embedded_worker_id;
-    bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(MessageReceiver, message)
-      IPC_MESSAGE_HANDLER(TestMsg_Message, OnMessage)
-      IPC_MESSAGE_UNHANDLED(handled = false)
-    IPC_END_MESSAGE_MAP()
-    return handled;
-  }
-
   void SimulateSendValueToBrowser(int embedded_worker_id, int value) {
     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));
   }
 
  private:
   void OnMessage() {
     // Do nothing.
   }
 
-  int current_embedded_worker_id_;
   DISALLOW_COPY_AND_ASSIGN(MessageReceiver);
 };
 
 void VerifyCalled(bool* called) {
   *called = true;
 }
 
 void ObserveStatusChanges(ServiceWorkerVersion* version,
                           std::vector<ServiceWorkerVersion::Status>* statuses) {
   statuses->push_back(version->status());
@@ skipping 1148 matching lines @@
   std::vector<GURL> valid_scopes;
   valid_scopes.push_back(valid_scope_1);
   valid_scopes.push_back(valid_scope_2);
 
   std::vector<url::Origin> all_origins;
   url::Origin valid_origin(GURL("https://chromium.org/"));
   std::vector<url::Origin> valid_origin_list(1, valid_origin);
 
   // Invalid subscope, should kill worker (but in tests will only increase bad
   // message count).
-  version_->OnRegisterForeignFetchScopes(std::vector<GURL>(1, GURL()),
-                                         valid_origin_list);
+  version_->RegisterForeignFetchScopes(std::vector<GURL>(1, GURL()),
+                                       valid_origin_list);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, helper_->mock_render_process_host()->bad_msg_count());
   EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size());
   EXPECT_EQ(0u, version_->foreign_fetch_origins_.size());
 
   // Subscope outside the scope of the worker.
-  version_->OnRegisterForeignFetchScopes(
+  version_->RegisterForeignFetchScopes(
       std::vector<GURL>(1, GURL("http://www.example.com/wrong")),
       valid_origin_list);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2, helper_->mock_render_process_host()->bad_msg_count());
   EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size());
   EXPECT_EQ(0u, version_->foreign_fetch_origins_.size());
 
   // Subscope on wrong origin.
-  version_->OnRegisterForeignFetchScopes(
+  version_->RegisterForeignFetchScopes(
       std::vector<GURL>(1, GURL("http://example.com/test/")),
       valid_origin_list);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(3, helper_->mock_render_process_host()->bad_msg_count());
   EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size());
   EXPECT_EQ(0u, version_->foreign_fetch_origins_.size());
 
   // Invalid origin.
-  version_->OnRegisterForeignFetchScopes(
+  version_->RegisterForeignFetchScopes(
       valid_scopes, std::vector<url::Origin>(1, url::Origin()));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(4, helper_->mock_render_process_host()->bad_msg_count());
   EXPECT_EQ(0u, version_->foreign_fetch_scopes_.size());
   EXPECT_EQ(0u, version_->foreign_fetch_origins_.size());
 
   // Valid subscope, no origins.
-  version_->OnRegisterForeignFetchScopes(std::vector<GURL>(1, valid_scope_1),
-                                         all_origins);
+  version_->RegisterForeignFetchScopes(std::vector<GURL>(1, valid_scope_1),
+                                       all_origins);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(4, helper_->mock_render_process_host()->bad_msg_count());
   EXPECT_EQ(1u, version_->foreign_fetch_scopes_.size());
   EXPECT_EQ(valid_scope_1, version_->foreign_fetch_scopes_[0]);
   EXPECT_EQ(0u, version_->foreign_fetch_origins_.size());
 
   // Valid subscope, explicit origins.
-  version_->OnRegisterForeignFetchScopes(valid_scopes, valid_origin_list);
+  version_->RegisterForeignFetchScopes(valid_scopes, valid_origin_list);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(4, helper_->mock_render_process_host()->bad_msg_count());
   EXPECT_EQ(2u, version_->foreign_fetch_scopes_.size());
   EXPECT_EQ(valid_scope_1, version_->foreign_fetch_scopes_[0]);
   EXPECT_EQ(valid_scope_2, version_->foreign_fetch_scopes_[1]);
   EXPECT_EQ(1u, version_->foreign_fetch_origins_.size());
   EXPECT_EQ(valid_origin, version_->foreign_fetch_origins_[0]);
 }
 
 TEST_F(ServiceWorkerVersionTest, RendererCrashDuringEvent) {
@@ skipping 21 matching lines @@
 
   // Callback completed.
   EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status);
   EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status());
 
   // Request already failed, calling finsh should return false.
   EXPECT_FALSE(version_->FinishRequest(request_id, true /* was_handled */,
                                        base::Time::Now()));
 }
 
-TEST_F(ServiceWorkerVersionTest, DispatchEvent) {
+TEST_F(ServiceWorkerVersionTest, RegisterRequestCallback) {
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK;  // 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.
   scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
   int request_id = version_->StartRequest(
       ServiceWorkerMetrics::EventType::SYNC,
       CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
   int received_request_id = 0;
   std::string received_data;
   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();
-  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.
   std::string reply("foobar");
   helper_->SimulateSendEventResult(
       version_->embedded_worker()->embedded_worker_id(), request_id, reply);
   runner->Run();
 
   // Verify message callback got called with correct reply.
   EXPECT_EQ(request_id, received_request_id);
   EXPECT_EQ(reply, received_data);
@@ skipping 80 matching lines @@
   // StartWorker message will be sent again because OnStopped is called before
   // OnStarted.
   version_->StopWorker(CreateReceiverOnCurrentThread(&status2));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(SERVICE_WORKER_OK, status1);
   EXPECT_EQ(SERVICE_WORKER_OK, status2);
   EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status());
 }
 
-TEST_F(ServiceWorkerVersionTest, DispatchConcurrentEvent) {
-  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK;  // 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 first request and dispatch test event.
-  scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner);
-  ServiceWorkerStatusCode status1 = SERVICE_WORKER_OK;  // dummy value
-  int request_id1 = version_->StartRequest(
-      ServiceWorkerMetrics::EventType::SYNC,
-      CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure()));
-  int received_request_id1 = 0;
-  std::string received_data1;
-  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);
-  ServiceWorkerStatusCode status2 = SERVICE_WORKER_OK;  // dummy value
-  int request_id2 = version_->StartRequest(
-      ServiceWorkerMetrics::EventType::SYNC,
-      CreateReceiverOnCurrentThread(&status2, runner2->QuitClosure()));
-  int received_request_id2 = 0;
-  std::string received_data2;
-  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();
-  ASSERT_EQ(2u, helper_->inner_ipc_sink()->message_count());
-  const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0);
-  ASSERT_EQ(TestMsg_TestEvent::ID, msg->type());
-  TestMsg_TestEvent::Param params;
-  TestMsg_TestEvent::Read(msg, &params);
-  EXPECT_EQ(request_id1, std::get<0>(params));
-  msg = helper_->inner_ipc_sink()->GetMessageAt(1);
-  ASSERT_EQ(TestMsg_TestEvent::ID, msg->type());
-  TestMsg_TestEvent::Read(msg, &params);
-  EXPECT_EQ(request_id2, std::get<0>(params));
-
-  // Reply to second event.
-  std::string reply2("foobar");
-  helper_->SimulateSendEventResult(
-      version_->embedded_worker()->embedded_worker_id(), request_id2, reply2);
-  runner2->Run();
-
-  // Verify correct message callback got called with correct reply.
-  EXPECT_EQ(0, received_request_id1);
-  EXPECT_EQ(request_id2, received_request_id2);
-  EXPECT_EQ(reply2, received_data2);
-  EXPECT_EQ(SERVICE_WORKER_OK, status2);
-  EXPECT_TRUE(version_->FinishRequest(request_id2, true /* was_handled */,
-                                      base::Time::Now()));
-
-  // Reply to first event.
-  std::string reply1("hello world");
-  helper_->SimulateSendEventResult(
-      version_->embedded_worker()->embedded_worker_id(), request_id1, reply1);
-  runner1->Run();
-
-  // 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, 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 /* was_handled */,
-                                      base::Time::Now()));
-  EXPECT_TRUE(version_->FinishRequest(request_id2, true /* was_handled */,
-                                      base::Time::Now()));
-}
-
 }  // namespace content