ServiceWorker: Mojofication of EWInstance::StopWorker

content/browser/service_worker/embedded_worker_test_helper.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/embedded_worker_test_helper.h"
 
 #include <map>
 #include <string>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/browser/message_port_message_filter.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_status.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/embedded_worker_setup.mojom.h"
 #include "content/common/service_worker/embedded_worker_start_params.h"
 #include "content/common/service_worker/fetch_event_dispatcher.mojom.h"
 #include "content/common/service_worker/service_worker_messages.h"
-#include "content/common/service_worker/service_worker_status_code.h"
 #include "content/public/common/push_event_payload.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "services/shell/public/cpp/interface_registry.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ skipping 16 matching lines @@
   ~MockMessagePortMessageFilter() override {}
   base::AtomicSequenceNumber next_routing_id_;
   ScopedVector<IPC::Message> message_queue_;
 };
 
 }  // namespace
 
 class EmbeddedWorkerTestHelper::MockEmbeddedWorkerSetup
     : public mojom::EmbeddedWorkerSetup {
  public:
+  explicit MockEmbeddedWorkerSetup(
+      const base::WeakPtr<EmbeddedWorkerTestHelper>& helper)
+      : helper_(helper) {}
+
   static void Create(const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
                      mojom::EmbeddedWorkerSetupRequest request) {
     mojo::MakeStrongBinding(base::MakeUnique<MockEmbeddedWorkerSetup>(helper),
                             std::move(request));
   }
 
-  explicit MockEmbeddedWorkerSetup(
-      const base::WeakPtr<EmbeddedWorkerTestHelper>& helper)
-      : helper_(helper) {}
-
-  ~MockEmbeddedWorkerSetup() override {}
-
   void ExchangeInterfaceProviders(
       int32_t thread_id,
       shell::mojom::InterfaceProviderRequest request,
       shell::mojom::InterfaceProviderPtr remote_interfaces) override {
     if (!helper_)
       return;
     helper_->OnSetupMojoStub(thread_id, std::move(request),
                              std::move(remote_interfaces));
   }
 
@@ skipping 16 matching lines @@
 
   embedded_worker_id_ = params.embedded_worker_id;
 
   EmbeddedWorkerInstance* worker =
       helper_->registry()->GetWorker(params.embedded_worker_id);
   ASSERT_TRUE(worker != NULL);
   EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status());
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker,
-                 helper_->weak_factory_.GetWeakPtr(), params.embedded_worker_id,
-                 params.service_worker_version_id, params.scope,
-                 params.script_url, params.pause_after_download));
+      base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker, helper_->AsWeakPtr(),
+                 params.embedded_worker_id, params.service_worker_version_id,
+                 params.scope, params.script_url, params.pause_after_download));
+}
+
+void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::StopWorker(
+    const StopWorkerCallback& callback) {
+  if (!helper_)
+    return;
+
+  ASSERT_TRUE(embedded_worker_id_);
+  EmbeddedWorkerInstance* worker =
+      helper_->registry()->GetWorker(embedded_worker_id_.value());
+  ASSERT_TRUE(worker != NULL);
+  EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, worker->status());
+
+  callback.Run();
 }
 
 // static
 void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::Bind(
     const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
     mojom::EmbeddedWorkerInstanceClientRequest request) {
   std::vector<std::unique_ptr<MockEmbeddedWorkerInstanceClient>>* clients =
       helper->mock_instance_clients();
   size_t next_client_index = helper->mock_instance_clients_next_index_;
 
@@ skipping 101 matching lines @@
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   // IPC::TestSink only records messages that are not handled by filters,
   // so we just forward all messages to the separate sink.
   sink_.OnMessageReceived(message);
 
   return handled;
 }
 
+void EmbeddedWorkerTestHelper::RegisterMockInstanceClient(
+    std::unique_ptr<MockEmbeddedWorkerInstanceClient> client) {
+  mock_instance_clients_.push_back(std::move(client));
+}
+
 ServiceWorkerContextCore* EmbeddedWorkerTestHelper::context() {
   return wrapper_->context();
 }
 
 void EmbeddedWorkerTestHelper::ShutdownContext() {
   wrapper_->Shutdown();
   wrapper_ = NULL;
 }
 
 void EmbeddedWorkerTestHelper::OnStartWorker(int embedded_worker_id,
@@ skipping 166 matching lines @@
 }
 
 void EmbeddedWorkerTestHelper::OnStartWorkerStub(
     const EmbeddedWorkerStartParams& params) {
   EmbeddedWorkerInstance* worker =
       registry()->GetWorker(params.embedded_worker_id);
   ASSERT_TRUE(worker != NULL);
   EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status());
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker,
-                 weak_factory_.GetWeakPtr(), params.embedded_worker_id,
-                 params.service_worker_version_id, params.scope,
-                 params.script_url, params.pause_after_download));
+      base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker, AsWeakPtr(),
+                 params.embedded_worker_id, params.service_worker_version_id,
+                 params.scope, params.script_url, params.pause_after_download));
 }
 
 void EmbeddedWorkerTestHelper::OnResumeAfterDownloadStub(
     int embedded_worker_id) {
   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
   ASSERT_TRUE(worker);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnResumeAfterDownload,
-                            weak_factory_.GetWeakPtr(), embedded_worker_id));
+                            AsWeakPtr(), embedded_worker_id));
 }
 
 void EmbeddedWorkerTestHelper::OnStopWorkerStub(int embedded_worker_id) {
   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
   ASSERT_TRUE(worker != NULL);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnStopWorker,
-                            weak_factory_.GetWeakPtr(), embedded_worker_id));
+                            AsWeakPtr(), embedded_worker_id));
 }
 
 void EmbeddedWorkerTestHelper::OnMessageToWorkerStub(
     int thread_id,
     int embedded_worker_id,
     const IPC::Message& message) {
   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
   ASSERT_TRUE(worker != NULL);
   EXPECT_EQ(worker->thread_id(), thread_id);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&EmbeddedWorkerTestHelper::OnMessageToWorker),
-          weak_factory_.GetWeakPtr(), thread_id, embedded_worker_id, message));
+          AsWeakPtr(), thread_id, embedded_worker_id, message));
 }
 
 void EmbeddedWorkerTestHelper::OnActivateEventStub(int request_id) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnActivateEvent,
-                            weak_factory_.GetWeakPtr(),
-                            current_embedded_worker_id_, request_id));
+      FROM_HERE,
+      base::Bind(&EmbeddedWorkerTestHelper::OnActivateEvent, AsWeakPtr(),
+                 current_embedded_worker_id_, request_id));
 }
 
 void EmbeddedWorkerTestHelper::OnExtendableMessageEventStub(
     int request_id,
     const ServiceWorkerMsg_ExtendableMessageEvent_Params& params) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnExtendableMessageEvent,
-                            weak_factory_.GetWeakPtr(),
-                            current_embedded_worker_id_, request_id));
+      FROM_HERE,
+      base::Bind(&EmbeddedWorkerTestHelper::OnExtendableMessageEvent,
+                 AsWeakPtr(), current_embedded_worker_id_, request_id));
 }
 
 void EmbeddedWorkerTestHelper::OnInstallEventStub(int request_id) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnInstallEvent,
-                            weak_factory_.GetWeakPtr(),
-                            current_embedded_worker_id_, request_id));
+      FROM_HERE,
+      base::Bind(&EmbeddedWorkerTestHelper::OnInstallEvent, AsWeakPtr(),
+                 current_embedded_worker_id_, request_id));
 }
 
 void EmbeddedWorkerTestHelper::OnFetchEventStub(
     int thread_id,
     int response_id,
     const ServiceWorkerFetchRequest& request,
     const FetchCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnFetchEvent,
-                            weak_factory_.GetWeakPtr(),
-                            thread_id_embedded_worker_id_map_[thread_id],
-                            response_id, request, callback));
+      FROM_HERE,
+      base::Bind(&EmbeddedWorkerTestHelper::OnFetchEvent, AsWeakPtr(),
+                 thread_id_embedded_worker_id_map_[thread_id], response_id,
+                 request, callback));
 }
 
 void EmbeddedWorkerTestHelper::OnPushEventStub(
     int request_id,
     const PushEventPayload& payload) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnPushEvent,
-                            weak_factory_.GetWeakPtr(),
+      FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnPushEvent, AsWeakPtr(),
                             current_embedded_worker_id_, request_id, payload));
 }
 
 void EmbeddedWorkerTestHelper::OnSetupMojoStub(
     int thread_id,
     shell::mojom::InterfaceProviderRequest request,
     shell::mojom::InterfaceProviderPtr remote_interfaces) {
   std::unique_ptr<shell::InterfaceRegistry> local(
       new shell::InterfaceRegistry);
   local->Bind(std::move(request));
@@ skipping 18 matching lines @@
       new MockMessagePortMessageFilter);
   message_port_message_filters_.push_back(filter);
   return filter.get();
 }
 
 std::unique_ptr<shell::InterfaceRegistry>
 EmbeddedWorkerTestHelper::CreateInterfaceRegistry(MockRenderProcessHost* rph) {
   std::unique_ptr<shell::InterfaceRegistry> registry(
       new shell::InterfaceRegistry);
   registry->AddInterface(
-      base::Bind(&MockEmbeddedWorkerSetup::Create, weak_factory_.GetWeakPtr()));
-  registry->AddInterface(base::Bind(&MockEmbeddedWorkerInstanceClient::Bind,
-                                    weak_factory_.GetWeakPtr()));
+      base::Bind(&MockEmbeddedWorkerSetup::Create, AsWeakPtr()));
+  registry->AddInterface(
+      base::Bind(&MockEmbeddedWorkerInstanceClient::Bind, AsWeakPtr()));
 
   shell::mojom::InterfaceProviderPtr interfaces;
   registry->Bind(mojo::GetProxy(&interfaces));
 
   std::unique_ptr<shell::InterfaceProvider> remote_interfaces(
       new shell::InterfaceProvider);
   remote_interfaces->Bind(std::move(interfaces));
   rph->SetRemoteInterfaces(std::move(remote_interfaces));
   return registry;
 }
 
 }  // namespace content