[ServiceWorker] Add EmbeddedWorkerInstanceHost Interface.

content/browser/service_worker/embedded_worker_instance_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/browser/service_worker/embedded_worker_instance.h"
 
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
@@ skipping 135 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerInstanceTest);
 };
 
 // A helper to simulate the start worker sequence is stalled in a worker
 // process.
 class StalledInStartWorkerHelper : public EmbeddedWorkerTestHelper {
  public:
   StalledInStartWorkerHelper() : EmbeddedWorkerTestHelper(base::FilePath()) {}
   ~StalledInStartWorkerHelper() override{};
 
-  void OnStartWorker(
-      int embedded_worker_id,
-      int64_t service_worker_version_id,
-      const GURL& scope,
-      const GURL& script_url,
-      bool pause_after_download,
-      mojom::ServiceWorkerEventDispatcherRequest request) override {
+  void OnStartWorker(int embedded_worker_id,
+                     int64_t service_worker_version_id,
+                     const GURL& scope,
+                     const GURL& script_url,
+                     bool pause_after_download,
+                     mojom::ServiceWorkerEventDispatcherRequest request,
+                     mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo
+                         instance_host) override {
     if (force_stall_in_start_) {
+      // Prepare for OnStopWorker().
+      instance_host_ptr_map_[embedded_worker_id].Bind(std::move(instance_host));
       // Do nothing to simulate a stall in the worker process.
       return;
     }
     EmbeddedWorkerTestHelper::OnStartWorker(
         embedded_worker_id, service_worker_version_id, scope, script_url,
-        pause_after_download, std::move(request));
+        pause_after_download, std::move(request), std::move(instance_host));
+  }
+
+  void OnStopWorker(int embedded_worker_id) override {
+    if (instance_host_ptr_map_[embedded_worker_id]) {
+      instance_host_ptr_map_[embedded_worker_id]->OnStopped();
+      base::RunLoop().RunUntilIdle();
+      return;
+    }
+    EmbeddedWorkerTestHelper::OnStopWorker(embedded_worker_id);
   }
 
   void set_force_stall_in_start(bool force_stall_in_start) {
     force_stall_in_start_ = force_stall_in_start;
   }
 
  private:
   bool force_stall_in_start_ = true;
+
+  std::map<
+      int /* embedded_worker_id */,
+      mojom::EmbeddedWorkerInstanceHostAssociatedPtr /* instance_host_ptr */>
+      instance_host_ptr_map_;
 };
 
 TEST_F(EmbeddedWorkerInstanceTest, StartAndStop) {
   std::unique_ptr<EmbeddedWorkerInstance> worker =
       embedded_worker_registry()->CreateWorker();
   EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status());
   worker->AddListener(this);
 
   const int64_t service_worker_version_id = 55L;
   const GURL pattern("http://example.com/");
@@ skipping 513 matching lines @@
 class FailEmbeddedWorkerInstanceClientImpl
     : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient {
  public:
   explicit FailEmbeddedWorkerInstanceClientImpl(
       base::WeakPtr<EmbeddedWorkerTestHelper> helper)
       : EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient(helper) {}
 
  private:
   void StartWorker(
       const EmbeddedWorkerStartParams& /* unused */,
-      mojom::ServiceWorkerEventDispatcherRequest /* unused */) override {
+      mojom::ServiceWorkerEventDispatcherRequest /* unused */,
+      mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo /* unused */)
+      override {
     helper_->mock_instance_clients()->clear();
   }
 };
 
 TEST_F(EmbeddedWorkerInstanceTest, RemoveRemoteInterface) {
   const int64_t version_id = 55L;
   const GURL pattern("http://example.com/");
   const GURL url("http://example.com/worker.js");
 
   // Let StartWorker fail; binding is discarded in the middle of IPC
@@ skipping 88 matching lines @@
   ASSERT_EQ(1UL, instance_client_rawptr->message().size());
   EXPECT_EQ(test_message, instance_client_rawptr->message()[0]);
 
   // Ensure the worker is stopped.
   worker->Stop();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status());
 }
 
 }  // namespace content