Manage ServiceWorkerDispatcherHost in ServiceWorkerContextCore

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 <stdint.h>
 
 #include <utility>
 
@@ skipping 43 matching lines @@
 
 }  // namespace
 
 static const int kRenderFrameId = 1;
 
 class TestingServiceWorkerDispatcherHost : public ServiceWorkerDispatcherHost {
  public:
   TestingServiceWorkerDispatcherHost(
       int process_id,
       ServiceWorkerContextWrapper* context_wrapper,
+      MessagePortMessageFilter* message_port_message_filter,
       ResourceContext* resource_context,
       EmbeddedWorkerTestHelper* helper)
-      : ServiceWorkerDispatcherHost(process_id, nullptr, resource_context),
+      : ServiceWorkerDispatcherHost(process_id,
+                                    message_port_message_filter,
+                                    resource_context),
         bad_messages_received_count_(0),
         helper_(helper) {
     Init(context_wrapper);
   }
 
   bool Send(IPC::Message* message) override { return helper_->Send(message); }
 
   IPC::TestSink* ipc_sink() { return helper_->ipc_sink(); }
 
   void ShutdownForBadMessage() override { ++bad_messages_received_count_; }
@@ skipping 36 matching lines @@
     helper_.reset();
   }
 
   ServiceWorkerContextCore* context() { return helper_->context(); }
   ServiceWorkerContextWrapper* context_wrapper() {
     return helper_->context_wrapper();
   }
 
   void Initialize(std::unique_ptr<EmbeddedWorkerTestHelper> helper) {
     helper_.reset(helper.release());
+    int process_id = helper_->mock_render_process_id();
+    // Inherit the message filter for message ports.
+    MessagePortMessageFilter* message_port_filter =
+        context()->GetDispatcherHost(process_id)->message_port_message_filter();
+    context()->RemoveDispatcherHost(process_id);
     dispatcher_host_ = new TestingServiceWorkerDispatcherHost(
-        helper_->mock_render_process_id(), context_wrapper(),
-        &resource_context_, helper_.get());
+        process_id, context_wrapper(), message_port_filter, &resource_context_,
+        helper_.get());
   }
 
   void SetUpRegistration(const GURL& scope, const GURL& script_url) {
     registration_ = new ServiceWorkerRegistration(
         scope, 1L, helper_->context()->AsWeakPtr());
     version_ = new ServiceWorkerVersion(registration_.get(), script_url, 1L,
                                         helper_->context()->AsWeakPtr());
     std::vector<ServiceWorkerDatabase::ResourceRecord> records;
     records.push_back(
         ServiceWorkerDatabase::ResourceRecord(10, version_->script_url(), 100));
@@ skipping 13 matching lines @@
         registration_.get(), version_.get(),
         base::Bind(&SaveStatusCallback, &called, &status));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(called);
     EXPECT_EQ(SERVICE_WORKER_OK, status);
   }
 
   void SendSetHostedVersionId(int provider_id,
                               int64_t version_id,
                               int embedded_worker_id) {
-    dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_SetVersionId(
-        provider_id, version_id, embedded_worker_id));
+    dispatcher_host_->OnSetHostedVersionId(provider_id, version_id,
+                                           embedded_worker_id);
   }
 
   void SendProviderCreated(ServiceWorkerProviderType type,
                            const GURL& pattern) {
     const int64_t kProviderId = 99;
-    dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
-        kProviderId, MSG_ROUTING_NONE, type,
-        true /* is_parent_frame_secure */));
+    ServiceWorkerProviderHostInfo info(kProviderId, MSG_ROUTING_NONE, type,
+                                       true);

[falken, 2017/02/13 05:59:24]

Let's document /* is_parent_frame_secure */ or reintroduce the enum. Sorry for
this mess, I originally did both boolean and enum and now I'm seeing it's too
confusing.

[shimazu, 2017/02/13 08:20:19]

Oops, I forgot to add the note, thanks:)

+    dispatcher_host_->OnProviderCreated(std::move(info));
     helper_->SimulateAddProcessToPattern(pattern,
                                          helper_->mock_render_process_id());
     provider_host_ = context()->GetProviderHost(
         helper_->mock_render_process_id(), kProviderId);
   }
 
   void SendRegister(int64_t provider_id, GURL pattern, GURL worker_url) {
     dispatcher_host_->OnMessageReceived(
         ServiceWorkerHostMsg_RegisterServiceWorker(
             -1, -1, provider_id, pattern, worker_url));
@@ skipping 60 matching lines @@
       const base::string16& message,
       const url::Origin& source_origin,
       const std::vector<int>& sent_message_ports,
       ServiceWorkerProviderHost* sender_provider_host,
       const ServiceWorkerDispatcherHost::StatusCallback& callback) {
     dispatcher_host_->DispatchExtendableMessageEvent(
         std::move(worker), message, source_origin, sent_message_ports,
         sender_provider_host, callback);
   }
 
-  ServiceWorkerProviderHost* CreateServiceWorkerProviderHost(int provider_id) {
-    return new ServiceWorkerProviderHost(
-        helper_->mock_render_process_id(), kRenderFrameId, provider_id,
-        SERVICE_WORKER_PROVIDER_FOR_WINDOW,
-        ServiceWorkerProviderHost::FrameSecurityLevel::SECURE,
-        context()->AsWeakPtr(), dispatcher_host_.get());
+  std::unique_ptr<ServiceWorkerProviderHost> CreateServiceWorkerProviderHost(
+      int provider_id) {
+    return CreateProviderHostWithDispatcherHost(
+        helper_->mock_render_process_id(), provider_id, context()->AsWeakPtr(),
+        kRenderFrameId, dispatcher_host_.get());
   }
 
   TestBrowserThreadBundle browser_thread_bundle_;
   content::MockResourceContext resource_context_;
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
   scoped_refptr<TestingServiceWorkerDispatcherHost> dispatcher_host_;
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
   ServiceWorkerProviderHost* provider_host_;
 };
@@ skipping 238 matching lines @@
   Register(-1,
            GURL(),
            GURL(),
            ServiceWorkerMsg_ServiceWorkerRegistrationError::ID);
 }
 
 TEST_F(ServiceWorkerDispatcherHostTest, ProviderCreatedAndDestroyed) {
   const int kProviderId = 1001;
   int process_id = helper_->mock_render_process_id();
 
-  dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
+  dispatcher_host_->OnProviderCreated(ServiceWorkerProviderHostInfo(
       kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
       true /* is_parent_frame_secure */));
   EXPECT_TRUE(context()->GetProviderHost(process_id, kProviderId));
 
   // Two with the same ID should be seen as a bad message.
-  dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
+  dispatcher_host_->OnProviderCreated(ServiceWorkerProviderHostInfo(
       kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
       true /* is_parent_frame_secure */));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 
-  dispatcher_host_->OnMessageReceived(
-      ServiceWorkerHostMsg_ProviderDestroyed(kProviderId));
+  dispatcher_host_->OnProviderDestroyed(kProviderId);
   EXPECT_FALSE(context()->GetProviderHost(process_id, kProviderId));
 
   // Destroying an ID that does not exist warrants a bad message.
-  dispatcher_host_->OnMessageReceived(
-      ServiceWorkerHostMsg_ProviderDestroyed(kProviderId));
+  dispatcher_host_->OnProviderDestroyed(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(
+  dispatcher_host_->OnProviderCreated(ServiceWorkerProviderHostInfo(
       kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
       true /* is_parent_frame_secure */));
   EXPECT_TRUE(context()->GetProviderHost(process_id, kProviderId));
   EXPECT_TRUE(dispatcher_host_->HasOneRef());
-  dispatcher_host_ = NULL;
+  dispatcher_host_ = nullptr;
   EXPECT_FALSE(context()->GetProviderHost(process_id, kProviderId));
 }
 
 TEST_F(ServiceWorkerDispatcherHostTest, GetRegistration_SameOrigin) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
@@ skipping 105 matching lines @@
   dispatcher_host_->OnFilterRemoved();
 
   // The dispatcher host should clean up the state from the process.
   EXPECT_FALSE(context()->GetProviderHost(process_id, provider_id));
   EXPECT_EQ(EmbeddedWorkerStatus::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(
-          process_id, context_wrapper(), &resource_context_, helper_.get()));
+      new TestingServiceWorkerDispatcherHost(process_id, context_wrapper(),
+                                             nullptr, &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(
+  new_dispatcher_host->OnProviderCreated(ServiceWorkerProviderHostInfo(
       provider_id, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
       true /* is_parent_frame_secure */));
   EXPECT_EQ(0, new_dispatcher_host->bad_messages_received_count_);
 }
 
 TEST_F(ServiceWorkerDispatcherHostTest, DispatchExtendableMessageEvent) {
   GURL pattern = GURL("http://www.example.com/");
   GURL script_url = GURL("http://www.example.com/service_worker.js");
 
   SendProviderCreated(SERVICE_WORKER_PROVIDER_FOR_CONTROLLER, pattern);
@@ skipping 163 matching lines @@
   dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_FetchEventResponse(
       version_->embedded_worker()->embedded_worker_id(), kFetchEventId,
       SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK, ServiceWorkerResponse(),
       base::Time::Now()));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, dispatcher_host_->bad_messages_received_count_);
 }
 
 }  // namespace content