Mojofy unittests: ServiceWorkerContextTest

content/browser/service_worker/service_worker_context_unittest.cc

 // Copyright 2013 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/public/browser/service_worker_context.h"
 
 #include <stdint.h>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_storage.h"
+#include "content/browser/service_worker/service_worker_test_utils.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
@@ skipping 121 matching lines @@
   }
 
   ServiceWorkerContextCore* context() { return helper_->context(); }
 
  protected:
   TestBrowserThreadBundle browser_thread_bundle_;
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
   std::vector<NotificationLog> notifications_;
 };
 
+class ServiceWorkerContextTestP
+    : public MojoServiceWorkerTestP<ServiceWorkerContextTest> {};
+
+class RecordableEmbeddedWorkerInstanceClient
+    : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient {
+ public:
+  enum class Message { StartWorker, StopWorker };
+
+  explicit RecordableEmbeddedWorkerInstanceClient(
+      base::WeakPtr<EmbeddedWorkerTestHelper> helper)
+      : EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient(helper) {}
+
+  const std::vector<Message>& events() const { return events_; }
+
+ protected:
+  void StartWorker(
+      const EmbeddedWorkerStartParams& params,
+      service_manager::mojom::InterfaceProviderPtr browser_interfaces,
+      service_manager::mojom::InterfaceProviderRequest renderer_request)
+      override {
+    events_.push_back(Message::StartWorker);
+    EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::StartWorker(
+        params, std::move(browser_interfaces), std::move(renderer_request));
+  }
+
+  void StopWorker(const StopWorkerCallback& callback) override {
+    events_.push_back(Message::StopWorker);
+    EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::StopWorker(
+        std::move(callback));
+  }
+
+  std::vector<Message> events_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RecordableEmbeddedWorkerInstanceClient);
+};
+
 // Make sure basic registration is working.
-TEST_F(ServiceWorkerContextTest, Register) {
+TEST_P(ServiceWorkerContextTestP, Register) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
+  RecordableEmbeddedWorkerInstanceClient* client = nullptr;
+  if (is_mojo_enabled()) {
+    client = helper_->CreateAndRegisterMockInstanceClient<
+        RecordableEmbeddedWorkerInstanceClient>(helper_->AsWeakPtr());
+  }
+
   int64_t registration_id = kInvalidServiceWorkerRegistrationId;
   bool called = false;
   context()->RegisterServiceWorker(
       pattern,
       script_url,
       NULL,
       MakeRegisteredCallback(&called, &registration_id));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
-  EXPECT_EQ(4UL, helper_->ipc_sink()->message_count());
-  EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-      EmbeddedWorkerMsg_StartWorker::ID));
-  EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-      ServiceWorkerMsg_InstallEvent::ID));
-  EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-      ServiceWorkerMsg_ActivateEvent::ID));
-  EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-      EmbeddedWorkerMsg_StopWorker::ID));
+  if (is_mojo_enabled()) {
+    EXPECT_EQ(2UL, helper_->ipc_sink()->message_count());
+    ASSERT_EQ(2UL, client->events().size());
+    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StartWorker,
+              client->events()[0]);
+    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_InstallEvent::ID));
+    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_ActivateEvent::ID));
+    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StopWorker,
+              client->events()[1]);
+  } else {
+    EXPECT_EQ(4UL, helper_->ipc_sink()->message_count());
+    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
+        EmbeddedWorkerMsg_StartWorker::ID));
+    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_InstallEvent::ID));
+    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_ActivateEvent::ID));
+    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
+        EmbeddedWorkerMsg_StopWorker::ID));
+  }
   EXPECT_NE(kInvalidServiceWorkerRegistrationId, registration_id);
 
   ASSERT_EQ(1u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(registration_id, notifications_[0].registration_id);
 
   context()->storage()->FindRegistrationForId(
       registration_id,
       pattern.GetOrigin(),
       base::Bind(&ExpectRegisteredWorkers,
                  SERVICE_WORKER_OK,
                  false /* expect_waiting */,
                  true /* expect_active */));
   base::RunLoop().RunUntilIdle();
 }
 
 // Test registration when the service worker rejects the install event. The
 // registration callback should indicate success, but there should be no waiting
 // or active worker in the registration.
-TEST_F(ServiceWorkerContextTest, Register_RejectInstall) {
+TEST_P(ServiceWorkerContextTestP, Register_RejectInstall) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   helper_.reset();  // Make sure the process lookups stay overridden.
   helper_.reset(new RejectInstallTestHelper);
   helper_->context_wrapper()->AddObserver(this);
+
+  RecordableEmbeddedWorkerInstanceClient* client = nullptr;
+  if (is_mojo_enabled()) {
+    client = helper_->CreateAndRegisterMockInstanceClient<
+        RecordableEmbeddedWorkerInstanceClient>(helper_->AsWeakPtr());
+  }
+
   int64_t registration_id = kInvalidServiceWorkerRegistrationId;
   bool called = false;
   context()->RegisterServiceWorker(
       pattern,
       script_url,
       NULL,
       MakeRegisteredCallback(&called, &registration_id));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
-  EXPECT_EQ(3UL, helper_->ipc_sink()->message_count());
-  EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-      EmbeddedWorkerMsg_StartWorker::ID));
-  EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-      ServiceWorkerMsg_InstallEvent::ID));
-  EXPECT_FALSE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-      ServiceWorkerMsg_ActivateEvent::ID));
-  EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-      EmbeddedWorkerMsg_StopWorker::ID));
+  if (is_mojo_enabled()) {
+    EXPECT_EQ(1UL, helper_->ipc_sink()->message_count());
+    ASSERT_EQ(2UL, client->events().size());
+    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StartWorker,
+              client->events()[0]);
+    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_InstallEvent::ID));
+    EXPECT_FALSE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_ActivateEvent::ID));
+    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StopWorker,
+              client->events()[1]);
+  } else {
+    EXPECT_EQ(3UL, helper_->ipc_sink()->message_count());
+    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
+        EmbeddedWorkerMsg_StartWorker::ID));
+    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_InstallEvent::ID));
+    EXPECT_FALSE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_ActivateEvent::ID));
+    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
+        EmbeddedWorkerMsg_StopWorker::ID));
+  }
   EXPECT_NE(kInvalidServiceWorkerRegistrationId, registration_id);
 
   ASSERT_EQ(1u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(registration_id, notifications_[0].registration_id);
 
   context()->storage()->FindRegistrationForId(
       registration_id,
       pattern.GetOrigin(),
       base::Bind(&ExpectRegisteredWorkers,
                  SERVICE_WORKER_ERROR_NOT_FOUND,
                  false /* expect_waiting */,
                  false /* expect_active */));
   base::RunLoop().RunUntilIdle();
 }
 
 // Test registration when the service worker rejects the activate event. The
 // worker should be activated anyway.
-TEST_F(ServiceWorkerContextTest, Register_RejectActivate) {
+TEST_P(ServiceWorkerContextTestP, Register_RejectActivate) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   helper_.reset();
   helper_.reset(new RejectActivateTestHelper);
   helper_->context_wrapper()->AddObserver(this);
+
+  RecordableEmbeddedWorkerInstanceClient* client = nullptr;
+  if (is_mojo_enabled()) {
+    client = helper_->CreateAndRegisterMockInstanceClient<
+        RecordableEmbeddedWorkerInstanceClient>(helper_->AsWeakPtr());
+  }
+
   int64_t registration_id = kInvalidServiceWorkerRegistrationId;
   bool called = false;
   context()->RegisterServiceWorker(
       pattern, script_url, NULL,
       MakeRegisteredCallback(&called, &registration_id));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
-  EXPECT_EQ(4UL, helper_->ipc_sink()->message_count());
-  EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-      EmbeddedWorkerMsg_StartWorker::ID));
-  EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-      ServiceWorkerMsg_InstallEvent::ID));
-  EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-      ServiceWorkerMsg_ActivateEvent::ID));
-  EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-      EmbeddedWorkerMsg_StopWorker::ID));
+  if (is_mojo_enabled()) {
+    EXPECT_EQ(2UL, helper_->ipc_sink()->message_count());
+    ASSERT_EQ(2UL, client->events().size());
+    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StartWorker,
+              client->events()[0]);
+    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_InstallEvent::ID));
+    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_ActivateEvent::ID));
+    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StopWorker,
+              client->events()[1]);
+  } else {
+    EXPECT_EQ(4UL, helper_->ipc_sink()->message_count());
+    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
+        EmbeddedWorkerMsg_StartWorker::ID));
+    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_InstallEvent::ID));
+    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+        ServiceWorkerMsg_ActivateEvent::ID));
+    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
+        EmbeddedWorkerMsg_StopWorker::ID));
+  }
   EXPECT_NE(kInvalidServiceWorkerRegistrationId, registration_id);
 
   ASSERT_EQ(1u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(registration_id, notifications_[0].registration_id);
 
   context()->storage()->FindRegistrationForId(
       registration_id, pattern.GetOrigin(),
       base::Bind(&ExpectRegisteredWorkers, SERVICE_WORKER_OK,
                  false /* expect_waiting */, true /* expect_active */));
   base::RunLoop().RunUntilIdle();
 }
 
 // Make sure registrations are cleaned up when they are unregistered.
-TEST_F(ServiceWorkerContextTest, Unregister) {
+TEST_P(ServiceWorkerContextTestP, Unregister) {
   GURL pattern("http://www.example.com/");
 
   bool called = false;
   int64_t registration_id = kInvalidServiceWorkerRegistrationId;
   context()->RegisterServiceWorker(
       pattern,
       GURL("http://www.example.com/service_worker.js"),
       NULL,
       MakeRegisteredCallback(&called, &registration_id));
 
@@ skipping 22 matching lines @@
   ASSERT_EQ(2u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(registration_id, notifications_[0].registration_id);
   EXPECT_EQ(REGISTRATION_DELETED, notifications_[1].type);
   EXPECT_EQ(pattern, notifications_[1].pattern);
   EXPECT_EQ(registration_id, notifications_[1].registration_id);
 }
 
 // Make sure registrations are cleaned up when they are unregistered in bulk.
-TEST_F(ServiceWorkerContextTest, UnregisterMultiple) {
+TEST_P(ServiceWorkerContextTestP, UnregisterMultiple) {
   GURL origin1_p1("http://www.example.com/test");
   GURL origin1_p2("http://www.example.com/hello");
   GURL origin2_p1("http://www.example.com:8080/again");
   GURL origin3_p1("http://www.other.com/");
 
   bool called = false;
   int64_t registration_id1 = kInvalidServiceWorkerRegistrationId;
   int64_t registration_id2 = kInvalidServiceWorkerRegistrationId;
   int64_t registration_id3 = kInvalidServiceWorkerRegistrationId;
   int64_t registration_id4 = kInvalidServiceWorkerRegistrationId;
@@ skipping 82 matching lines @@
   EXPECT_EQ(registration_id4, notifications_[3].registration_id);
   EXPECT_EQ(REGISTRATION_DELETED, notifications_[4].type);
   EXPECT_EQ(origin1_p2, notifications_[4].pattern);
   EXPECT_EQ(registration_id2, notifications_[4].registration_id);
   EXPECT_EQ(REGISTRATION_DELETED, notifications_[5].type);
   EXPECT_EQ(origin1_p1, notifications_[5].pattern);
   EXPECT_EQ(registration_id1, notifications_[5].registration_id);
 }
 
 // Make sure registering a new script shares an existing registration.
-TEST_F(ServiceWorkerContextTest, RegisterNewScript) {
+TEST_P(ServiceWorkerContextTestP, RegisterNewScript) {
   GURL pattern("http://www.example.com/");
 
   bool called = false;
   int64_t old_registration_id = kInvalidServiceWorkerRegistrationId;
   context()->RegisterServiceWorker(
       pattern,
       GURL("http://www.example.com/service_worker.js"),
       NULL,
       MakeRegisteredCallback(&called, &old_registration_id));
 
@@ skipping 21 matching lines @@
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(old_registration_id, notifications_[0].registration_id);
   EXPECT_EQ(REGISTRATION_STORED, notifications_[1].type);
   EXPECT_EQ(pattern, notifications_[1].pattern);
   EXPECT_EQ(new_registration_id, notifications_[1].registration_id);
 }
 
 // Make sure that when registering a duplicate pattern+script_url
 // combination, that the same registration is used.
-TEST_F(ServiceWorkerContextTest, RegisterDuplicateScript) {
+TEST_P(ServiceWorkerContextTestP, RegisterDuplicateScript) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   bool called = false;
   int64_t old_registration_id = kInvalidServiceWorkerRegistrationId;
   context()->RegisterServiceWorker(
       pattern,
       script_url,
       NULL,
       MakeRegisteredCallback(&called, &old_registration_id));
@@ skipping 18 matching lines @@
 
   ASSERT_EQ(2u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(old_registration_id, notifications_[0].registration_id);
   EXPECT_EQ(REGISTRATION_STORED, notifications_[1].type);
   EXPECT_EQ(pattern, notifications_[1].pattern);
   EXPECT_EQ(old_registration_id, notifications_[1].registration_id);
 }
 
-TEST_F(ServiceWorkerContextTest, ProviderHostIterator) {
+TEST_P(ServiceWorkerContextTestP, ProviderHostIterator) {
   const int kRenderProcessId1 = 1;
   const int kRenderProcessId2 = 2;
   const GURL kOrigin1 = GURL("http://www.example.com/");
   const GURL kOrigin2 = GURL("https://www.example.com/");
   int provider_id = 1;
 
   // Host1 (provider_id=1): process_id=1, origin1.
   ServiceWorkerProviderHost* host1(new ServiceWorkerProviderHost(
       kRenderProcessId1, MSG_ROUTING_NONE, provider_id++,
       SERVICE_WORKER_PROVIDER_FOR_WINDOW,
@@ skipping 63 matching lines @@
   EXPECT_TRUE(ContainsKey(results, host2));
 
   context()->RemoveProviderHost(kRenderProcessId1, 1);
   context()->RemoveProviderHost(kRenderProcessId2, 2);
   context()->RemoveProviderHost(kRenderProcessId2, 3);
   context()->RemoveProviderHost(kRenderProcessId2, 4);
 }
 
 class ServiceWorkerContextRecoveryTest
     : public ServiceWorkerContextTest,
-      public testing::WithParamInterface<bool> {
+      public testing::WithParamInterface<testing::tuple<bool, bool>> {
  public:
   ServiceWorkerContextRecoveryTest() {}
   virtual ~ServiceWorkerContextRecoveryTest() {}
+
+ protected:
+  void SetUp() override {
+    if (is_mojo_enabled()) {
+      base::CommandLine::ForCurrentProcess()->AppendSwitch(
+          switches::kMojoServiceWorker);
+    }
+    ServiceWorkerContextTest::SetUp();
+  }
+
+  bool is_mojo_enabled() const { return testing::get<0>(GetParam()); }
+  bool is_storage_on_disk() const { return testing::get<1>(GetParam()); }
 };
 
-INSTANTIATE_TEST_CASE_P(ServiceWorkerContextRecoveryTest,
-                        ServiceWorkerContextRecoveryTest,
-                        testing::Values(true, false));
-
 TEST_P(ServiceWorkerContextRecoveryTest, DeleteAndStartOver) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
-  bool is_storage_on_disk = GetParam();
-  if (is_storage_on_disk) {
+  if (is_storage_on_disk()) {
     // Reinitialize the helper to test on-disk storage.
     base::ScopedTempDir user_data_directory;
     ASSERT_TRUE(user_data_directory.CreateUniqueTempDir());
     helper_.reset(new EmbeddedWorkerTestHelper(user_data_directory.GetPath()));
     helper_->context_wrapper()->AddObserver(this);
   }
 
   int64_t registration_id = kInvalidServiceWorkerRegistrationId;
   bool called = false;
   context()->RegisterServiceWorker(
@@ skipping 67 matching lines @@
   ASSERT_EQ(3u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(registration_id, notifications_[0].registration_id);
   EXPECT_EQ(STORAGE_RECOVERED, notifications_[1].type);
   EXPECT_EQ(REGISTRATION_STORED, notifications_[2].type);
   EXPECT_EQ(pattern, notifications_[2].pattern);
   EXPECT_EQ(registration_id, notifications_[2].registration_id);
 }
 
+INSTANTIATE_TEST_CASE_P(ServiceWorkerContextTest,
+                        ServiceWorkerContextTestP,
+                        testing::Bool());
+
+INSTANTIATE_TEST_CASE_P(ServiceWorkerContextRecoveryTest,
+                        ServiceWorkerContextRecoveryTest,
+                        testing::Combine(testing::Bool(), testing::Bool()));
 
 }  // namespace content