[ServiceWorker] Add EmbeddedWorkerInstanceHost Interface.

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 274 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersionTest);
 };
 
 class MessageReceiverDisallowStart : public MessageReceiver {
  public:
   MessageReceiverDisallowStart() : MessageReceiver() {}
   ~MessageReceiverDisallowStart() override {}
 
   enum class StartMode { STALL, FAIL, SUCCEED };
 
-  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 {
     switch (mode_) {
       case StartMode::STALL:
+        // Prepare for OnStopWorker().
+        instance_host_ptr_map_[embedded_worker_id].Bind(
+            std::move(instance_host));
         break;  // Do nothing.
       case StartMode::FAIL:
         ASSERT_EQ(current_mock_instance_index_ + 1,
                   mock_instance_clients()->size());
         // Remove the connection by peer
         mock_instance_clients()->at(current_mock_instance_index_).reset();
         break;
       case StartMode::SUCCEED:
         MessageReceiver::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));
         break;
     }
     current_mock_instance_index_++;
   }
 
+  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_start_mode(StartMode mode) { mode_ = mode; }
 
  private:
   uint32_t current_mock_instance_index_ = 0;
   StartMode mode_ = StartMode::STALL;
+
+  std::map<
+      int /* embedded_worker_id */,
+      mojom::EmbeddedWorkerInstanceHostAssociatedPtr /* instance_host_ptr */>
+      instance_host_ptr_map_;
   DISALLOW_COPY_AND_ASSIGN(MessageReceiverDisallowStart);
 };
 
 class ServiceWorkerFailToStartTest : public ServiceWorkerVersionTest {
  protected:
   ServiceWorkerFailToStartTest() : ServiceWorkerVersionTest() {}
 
   void set_start_mode(MessageReceiverDisallowStart::StartMode mode) {
     MessageReceiverDisallowStart* helper =
         static_cast<MessageReceiverDisallowStart*>(helper_.get());
     helper->set_start_mode(mode);
   }
 
   std::unique_ptr<MessageReceiver> GetMessageReceiver() override {
     return base::MakeUnique<MessageReceiverDisallowStart>();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerFailToStartTest);
 };
 
 class NoOpStopWorkerEmbeddedWorkerInstanceClient
     : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient {
  public:
   explicit NoOpStopWorkerEmbeddedWorkerInstanceClient(
       base::WeakPtr<EmbeddedWorkerTestHelper> helper)
       : EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient(helper) {}
   ~NoOpStopWorkerEmbeddedWorkerInstanceClient() override {
-    // Stop callback should be called once.
-    if (pending_stop_callback_)
-      pending_stop_callback_.Run();
   }
 
  protected:
-  void StopWorker(const StopWorkerCallback& callback) override {
-    pending_stop_callback_ = std::move(callback);
+  void StopWorker() override {
     // Do nothing.
   }
 
-  StopWorkerCallback pending_stop_callback_;
-
  private:
   DISALLOW_COPY_AND_ASSIGN(NoOpStopWorkerEmbeddedWorkerInstanceClient);
 };
 
 class MessageReceiverDisallowStop : public MessageReceiver {
  public:
   MessageReceiverDisallowStop() : MessageReceiver() {
     CreateAndRegisterMockInstanceClient<
         NoOpStopWorkerEmbeddedWorkerInstanceClient>(AsWeakPtr());
   }
   ~MessageReceiverDisallowStop() override {}
 
-  void OnStopWorker(
-      const mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback& callback)
-      override {
+  void OnStopWorker(int embedded_worker_id) override {
     // Do nothing.
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MessageReceiverDisallowStop);
 };
 
 class ServiceWorkerStallInStoppingTest : public ServiceWorkerVersionTest {
  protected:
   ServiceWorkerStallInStoppingTest() : ServiceWorkerVersionTest() {}
@@ skipping 432 matching lines @@
   ~MessageReceiverControlEvents() override {}
 
   void OnExtendableMessageEvent(
       mojom::ExtendableMessageEventPtr event,
       const mojom::ServiceWorkerEventDispatcher::
           DispatchExtendableMessageEventCallback& callback) override {
     EXPECT_FALSE(extendable_message_event_callback_);
     extendable_message_event_callback_ = callback;
   }
 
-  void OnStopWorker(
-      const mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback& callback)
-      override {
+  void OnStopWorker(int embedded_worker_id) override {
     EXPECT_FALSE(stop_worker_callback_);
-    stop_worker_callback_ = callback;
+    stop_worker_callback_ =
+        base::Bind(&MessageReceiverControlEvents::SimulateWorkerStopped,
+                   base::Unretained(this), embedded_worker_id);
   }
 
   const mojom::ServiceWorkerEventDispatcher::
       DispatchExtendableMessageEventCallback&
       extendable_message_event_callback() {
     return extendable_message_event_callback_;
   }
 
-  const mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback&
-  stop_worker_callback() {
-    return stop_worker_callback_;
-  }
+  const base::Closure& stop_worker_callback() { return stop_worker_callback_; }
 
  private:
   mojom::ServiceWorkerEventDispatcher::DispatchExtendableMessageEventCallback
       extendable_message_event_callback_;
-  mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback stop_worker_callback_;
+  base::Closure stop_worker_callback_;
 };
 
 class ServiceWorkerRequestTimeoutTest : public ServiceWorkerVersionTest {
  protected:
   ServiceWorkerRequestTimeoutTest() : ServiceWorkerVersionTest() {}
 
   std::unique_ptr<MessageReceiver> GetMessageReceiver() override {
     return base::MakeUnique<MessageReceiverControlEvents>();
   }
 
   const mojom::ServiceWorkerEventDispatcher::
       DispatchExtendableMessageEventCallback&
       extendable_message_event_callback() {
     return static_cast<MessageReceiverControlEvents*>(helper_.get())
         ->extendable_message_event_callback();
   }
 
-  const mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback&
-  stop_worker_callback() {
+  const base::Closure& stop_worker_callback() {
     return static_cast<MessageReceiverControlEvents*>(helper_.get())
         ->stop_worker_callback();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRequestTimeoutTest);
 };
 
 TEST_F(ServiceWorkerRequestTimeoutTest, RequestTimeout) {
   ServiceWorkerStatusCode error_status =
@@ skipping 721 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