Fix a failing service worker startup test to work with mojo IPC

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 278 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersionTest);
 };
 
 class ServiceWorkerVersionTestP
     : public MojoServiceWorkerTestP<ServiceWorkerVersionTest> {};
 
 class MessageReceiverDisallowStart : public MessageReceiver {
  public:
-  MessageReceiverDisallowStart()
-      : MessageReceiver() {}
+  MessageReceiverDisallowStart(bool is_mojo_enabled)
+      : MessageReceiver(), is_mojo_enabled_(is_mojo_enabled) {}
   ~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) override {
     switch (mode_) {
       case StartMode::STALL:
         break;  // Do nothing.
       case StartMode::FAIL:
-        OnStopWorker(embedded_worker_id);
+        if (is_mojo_enabled_) {
+          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();
+        } else {
+          OnStopWorker(embedded_worker_id);
+        }
         break;
       case StartMode::SUCCEED:
         MessageReceiver::OnStartWorker(embedded_worker_id,
                                        service_worker_version_id, scope,
                                        script_url, pause_after_download);
         break;
     }
+    current_mock_instance_index_++;
   }
 
   void set_start_mode(StartMode mode) { mode_ = mode; }
 
  private:
+  const bool is_mojo_enabled_;
+  uint32_t current_mock_instance_index_ = 0;
   StartMode mode_ = StartMode::STALL;
   DISALLOW_COPY_AND_ASSIGN(MessageReceiverDisallowStart);
 };
 
 class ServiceWorkerFailToStartTest : public ServiceWorkerVersionTestP {
  protected:
   ServiceWorkerFailToStartTest() : ServiceWorkerVersionTestP() {}
 
   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>();
+    return base::MakeUnique<MessageReceiverDisallowStart>(is_mojo_enabled());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerFailToStartTest);
 };
 
 class NoOpStopWorkerEmbeddedWorkerInstanceClient
     : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient {
  public:
   explicit NoOpStopWorkerEmbeddedWorkerInstanceClient(
@@ skipping 1432 matching lines @@
                         ServiceWorkerNavigationHintUMATest,
                         testing::Bool());
 INSTANTIATE_TEST_CASE_P(ServiceWorkerStallInStoppingTest,
                         ServiceWorkerStallInStoppingTest,
                         testing::Bool());
 INSTANTIATE_TEST_CASE_P(ServiceWorkerVersionWithMojoTest,
                         ServiceWorkerVersionWithMojoTest,
                         testing::Bool());
 
 }  // namespace content