WIP attempt to replace StartWorker/StopWorker IPCs with a new mojo EmbeddedWorker service.

content/browser/service_worker/service_worker_dispatcher_host_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/service_worker_dispatcher_host.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/embedded_worker_instance.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_wrapper.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/common/content_switches.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "content/test/test_content_browser_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 static void SaveStatusCallback(bool* called,
                                ServiceWorkerStatusCode* out,
                                ServiceWorkerStatusCode status) {
   *called = true;
   *out = status;
 }
 
+class IPCWaiter : public IPC::Listener {
+ public:
+  explicit IPCWaiter(uint32 expected_message)
+      : expected_message_(expected_message), runner_(new MessageLoopRunner) {}
+
+  void Wait() { runner_->Run(); }
+
+  bool OnMessageReceived(const IPC::Message& message) override {
+    if (message.type() == expected_message_)
+      runner_->Quit();
+    return false;
+  }
+
+ private:
+  uint32 expected_message_;
+  scoped_refptr<MessageLoopRunner> runner_;
+};
 }
 
-static const int kRenderProcessId = 1;
 static const int kRenderFrameId = 1;
 
 class TestingServiceWorkerDispatcherHost : public ServiceWorkerDispatcherHost {
  public:
   TestingServiceWorkerDispatcherHost(
       int process_id,
       ServiceWorkerContextWrapper* context_wrapper,
       ResourceContext* resource_context,
       EmbeddedWorkerTestHelper* helper)
       : ServiceWorkerDispatcherHost(process_id, NULL, resource_context),
@@ skipping 14 matching lines @@
   EmbeddedWorkerTestHelper* helper_;
   ~TestingServiceWorkerDispatcherHost() override {}
 };
 
 class ServiceWorkerDispatcherHostTest : public testing::Test {
  protected:
   ServiceWorkerDispatcherHostTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
 
   void SetUp() override {
-    helper_.reset(
-        new EmbeddedWorkerTestHelper(base::FilePath(), kRenderProcessId));
+    helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
     dispatcher_host_ = new TestingServiceWorkerDispatcherHost(
-        kRenderProcessId, context_wrapper(), &resource_context_, helper_.get());
+        helper_->mock_render_process_id(), context_wrapper(),
+        &resource_context_, helper_.get());
   }
 
   void TearDown() override { helper_.reset(); }
 
   ServiceWorkerContextCore* context() { return helper_->context(); }
   ServiceWorkerContextWrapper* context_wrapper() {
     return helper_->context_wrapper();
   }
 
   void SendRegister(int64 provider_id, GURL pattern, GURL worker_url) {
     dispatcher_host_->OnMessageReceived(
         ServiceWorkerHostMsg_RegisterServiceWorker(
             -1, -1, provider_id, pattern, worker_url));
     base::RunLoop().RunUntilIdle();
   }
 
   void Register(int64 provider_id,
                 GURL pattern,
                 GURL worker_url,
                 uint32 expected_message) {
+    IPCWaiter waiter(expected_message);
+    dispatcher_host_->ipc_sink()->AddFilter(&waiter);
     SendRegister(provider_id, pattern, worker_url);
+    waiter.Wait();
     EXPECT_TRUE(dispatcher_host_->ipc_sink()->GetUniqueMessageMatching(
         expected_message));
     dispatcher_host_->ipc_sink()->ClearMessages();
+    dispatcher_host_->ipc_sink()->RemoveFilter(&waiter);
   }
 
   void SendUnregister(int64 provider_id, int64 registration_id) {
     dispatcher_host_->OnMessageReceived(
         ServiceWorkerHostMsg_UnregisterServiceWorker(-1, -1, provider_id,
                                                      registration_id));
     base::RunLoop().RunUntilIdle();
   }
 
   void Unregister(int64 provider_id,
@@ skipping 29 matching lines @@
 
   void GetRegistrations(int64 provider_id, uint32 expected_message) {
     SendGetRegistrations(provider_id);
     EXPECT_TRUE(dispatcher_host_->ipc_sink()->GetUniqueMessageMatching(
         expected_message));
     dispatcher_host_->ipc_sink()->ClearMessages();
   }
 
   ServiceWorkerProviderHost* CreateServiceWorkerProviderHost(int provider_id) {
     return new ServiceWorkerProviderHost(
-        kRenderProcessId, kRenderFrameId, provider_id,
+        helper_->mock_render_process_id(), kRenderFrameId, provider_id,
         SERVICE_WORKER_PROVIDER_FOR_WINDOW, context()->AsWeakPtr(),
         dispatcher_host_.get());
   }
 
 
   TestBrowserThreadBundle browser_thread_bundle_;
   content::MockResourceContext resource_context_;
   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
   scoped_refptr<TestingServiceWorkerDispatcherHost> dispatcher_host_;
 };
@@ skipping 208 matching lines @@
            GURL(),
            GURL(),
            ServiceWorkerMsg_ServiceWorkerRegistrationError::ID);
 }
 
 TEST_F(ServiceWorkerDispatcherHostTest, ProviderCreatedAndDestroyed) {
   const int kProviderId = 1001;  // Test with a value != kRenderProcessId.
 
   dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
       kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW));
-  EXPECT_TRUE(context()->GetProviderHost(kRenderProcessId, kProviderId));
+  EXPECT_TRUE(context()->GetProviderHost(helper_->mock_render_process_id(),
+                                         kProviderId));
 
   // Two with the same ID should be seen as a bad message.
   dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
       kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 
   dispatcher_host_->OnMessageReceived(
       ServiceWorkerHostMsg_ProviderDestroyed(kProviderId));
-  EXPECT_FALSE(context()->GetProviderHost(kRenderProcessId, kProviderId));
+  EXPECT_FALSE(context()->GetProviderHost(helper_->mock_render_process_id(),
+                                          kProviderId));
 
   // Destroying an ID that does not exist warrants a bad message.
   dispatcher_host_->OnMessageReceived(
       ServiceWorkerHostMsg_ProviderDestroyed(kProviderId));
   EXPECT_EQ(2, dispatcher_host_->bad_messages_received_count_);
 
   // Deletion of the dispatcher_host should cause providers for that
   // process to get deleted as well.
   dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
       kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW));
-  EXPECT_TRUE(context()->GetProviderHost(kRenderProcessId, kProviderId));
+  EXPECT_TRUE(context()->GetProviderHost(helper_->mock_render_process_id(),
+                                         kProviderId));
   EXPECT_TRUE(dispatcher_host_->HasOneRef());
   dispatcher_host_ = NULL;
-  EXPECT_FALSE(context()->GetProviderHost(kRenderProcessId, kProviderId));
+  EXPECT_FALSE(context()->GetProviderHost(helper_->mock_render_process_id(),
+                                          kProviderId));
 }
 
 TEST_F(ServiceWorkerDispatcherHostTest, GetRegistration_SameOrigin) {
   const int64 kProviderId = 99;  // Dummy value
   scoped_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(host.Pass());
 
   GetRegistration(kProviderId,
@@ skipping 105 matching lines @@
   bool called = false;
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_ABORT;
   helper_->context()->storage()->StoreRegistration(
       registration.get(),
       version.get(),
       base::Bind(&SaveStatusCallback, &called, &status));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   ASSERT_EQ(SERVICE_WORKER_OK, status);
 
-  helper_->SimulateAddProcessToPattern(pattern, kRenderProcessId);
+  helper_->SimulateAddProcessToPattern(pattern,
+                                       helper_->mock_render_process_id());
 
   // Start up the worker.
   status = SERVICE_WORKER_ERROR_ABORT;
-  version->StartWorker(base::Bind(&SaveStatusCallback, &called, &status));
-  base::RunLoop().RunUntilIdle();
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
+  version->StartWorker(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
+  runner->Run();
 
-  EXPECT_TRUE(called);
   EXPECT_EQ(SERVICE_WORKER_OK, status);
 
-  EXPECT_TRUE(context()->GetProviderHost(kRenderProcessId, kProviderId));
+  EXPECT_TRUE(context()->GetProviderHost(helper_->mock_render_process_id(),
+                                         kProviderId));
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version->running_status());
 
   // Simulate the render process crashing.
   dispatcher_host_->OnFilterRemoved();
 
   // The dispatcher host should clean up the state from the process.
-  EXPECT_FALSE(context()->GetProviderHost(kRenderProcessId, kProviderId));
+  EXPECT_FALSE(context()->GetProviderHost(helper_->mock_render_process_id(),
+                                          kProviderId));
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version->running_status());
 
   // We should be able to hook up a new dispatcher host although the old object
   // is not yet destroyed. This is what the browser does when reusing a crashed
   // render process.
   scoped_refptr<TestingServiceWorkerDispatcherHost> new_dispatcher_host(
-      new TestingServiceWorkerDispatcherHost(kRenderProcessId,
-                                             context_wrapper(),
-                                             &resource_context_,
-                                             helper_.get()));
+      new TestingServiceWorkerDispatcherHost(
+          helper_->mock_render_process_id(), context_wrapper(),
+          &resource_context_, helper_.get()));
 
   // To show the new dispatcher can operate, simulate provider creation. Since
   // the old dispatcher cleaned up the old provider host, the new one won't
   // complain.
   new_dispatcher_host->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
       kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW));
   EXPECT_EQ(0, new_dispatcher_host->bad_messages_received_count_);
 }
 
 }  // namespace content