Add two interfaces for ServiceWorkerProviderContext/ProviderHost

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>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.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_status.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_handle.h"
+#include "content/browser/service_worker/service_worker_navigation_handle_core.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/common/service_worker/service_worker_types.h"
 #include "content/common/service_worker/service_worker_utils.h"
+#include "content/public/common/browser_side_navigation_policy.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/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;
 }
 
 void SetUpDummyMessagePort(std::vector<MessagePort>* ports) {
   // Let the other end of the pipe close.
   mojo::MessagePipe pipe;
   ports->push_back(MessagePort(std::move(pipe.handle0)));
 }
 
+struct RemoteProviderInfo {
+  mojom::ServiceWorkerProviderHostAssociatedPtr host_ptr;
+  mojom::ServiceWorkerProviderAssociatedRequest client_request;
+};
+
+RemoteProviderInfo SetupProviderHostInfoPtrs(
+    ServiceWorkerProviderHostInfo* host_info) {
+  RemoteProviderInfo remote_info;
+  mojom::ServiceWorkerProviderAssociatedPtr browser_side_client_ptr;
+  remote_info.client_request =
+      mojo::MakeIsolatedRequest(&browser_side_client_ptr);
+  host_info->host_request = mojo::MakeIsolatedRequest(&remote_info.host_ptr);
+  host_info->client_ptr_info = browser_side_client_ptr.PassInterface();
+  EXPECT_TRUE(host_info->host_request.is_pending());
+  EXPECT_TRUE(host_info->client_ptr_info.is_valid());
+  EXPECT_TRUE(remote_info.host_ptr.is_bound());
+  EXPECT_TRUE(remote_info.client_request.is_pending());
+  return remote_info;
+}
+
+std::unique_ptr<ServiceWorkerNavigationHandleCore> CreateNavigationHandleCore(
+    ServiceWorkerContextWrapper* context_wrapper) {
+  std::unique_ptr<ServiceWorkerNavigationHandleCore> navigation_handle_core;
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(
+          [](ServiceWorkerContextWrapper* wrapper) {
+            return base::MakeUnique<ServiceWorkerNavigationHandleCore>(nullptr,
+                                                                       wrapper);
+          },
+          context_wrapper),
+      base::Bind(
+          [](std::unique_ptr<ServiceWorkerNavigationHandleCore>* dest,
+             std::unique_ptr<ServiceWorkerNavigationHandleCore> src) {
+            *dest = std::move(src);
+          },
+          &navigation_handle_core));
+  base::RunLoop().RunUntilIdle();
+  return navigation_handle_core;
+}
+
 }  // namespace
 
 static const int kRenderFrameId = 1;
 
 class TestingServiceWorkerDispatcherHost : public ServiceWorkerDispatcherHost {
  public:
   TestingServiceWorkerDispatcherHost(
       int process_id,
       ServiceWorkerContextWrapper* context_wrapper,
       ResourceContext* resource_context,
@@ skipping 98 matching lines @@
                               int 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;
     ServiceWorkerProviderHostInfo info(kProviderId, MSG_ROUTING_NONE, type,
                                        true /* is_parent_frame_secure */);
+    remote_endpoint_.BindWithProviderHostInfo(&info);
+
     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(
@@ skipping 65 matching lines @@
       const ServiceWorkerDispatcherHost::StatusCallback& callback) {
     dispatcher_host_->DispatchExtendableMessageEvent(
         std::move(worker), message, source_origin, sent_message_ports,
         sender_provider_host, callback);
   }
 
   std::unique_ptr<ServiceWorkerProviderHost> CreateServiceWorkerProviderHost(
       int provider_id) {
     return CreateProviderHostWithDispatcherHost(
         helper_->mock_render_process_id(), provider_id, context()->AsWeakPtr(),
-        kRenderFrameId, dispatcher_host_.get());
+        kRenderFrameId, dispatcher_host_.get(), &remote_endpoint_);
   }
 
   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_;
+  ServiceWorkerRemoteProviderEndpoint remote_endpoint_;
 };
 
 class ServiceWorkerTestContentBrowserClient : public TestContentBrowserClient {
  public:
   ServiceWorkerTestContentBrowserClient() {}
   bool AllowServiceWorker(
       const GURL& scope,
       const GURL& first_party,
       content::ResourceContext* context,
       const base::Callback<WebContents*(void)>& wc_getter) override {
@@ skipping 226 matching lines @@
   // Let the shutdown reach the simulated IO thread.
   base::RunLoop().RunUntilIdle();
 
   Register(-1,
            GURL(),
            GURL(),
            ServiceWorkerMsg_ServiceWorkerRegistrationError::ID);
 }
 
 TEST_F(ServiceWorkerDispatcherHostTest, ProviderCreatedAndDestroyed) {
-  const int kProviderId = 1001;
+  // |kProviderId| must be -2 when PlzNavigate is enabled to match the
+  // pre-created provider host. Otherwise |kProviderId| is just a dummy value.
+  const int kProviderId = (IsBrowserSideNavigationEnabled() ? -2 : 1001);
   int process_id = helper_->mock_render_process_id();
 
-  dispatcher_host_->OnProviderCreated(ServiceWorkerProviderHostInfo(
-      kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
-      true /* is_parent_frame_secure */));
+  // Setup ServiceWorkerProviderHostInfo.
+  ServiceWorkerProviderHostInfo host_info_1(kProviderId, 1 /* route_id */,
+                                            SERVICE_WORKER_PROVIDER_FOR_WINDOW,
+                                            true /* is_parent_frame_secure */);
+  ServiceWorkerProviderHostInfo host_info_2(kProviderId, 1 /* route_id */,
+                                            SERVICE_WORKER_PROVIDER_FOR_WINDOW,
+                                            true /* is_parent_frame_secure */);
+  ServiceWorkerProviderHostInfo host_info_3(kProviderId, 1 /* route_id */,
+                                            SERVICE_WORKER_PROVIDER_FOR_WINDOW,
+                                            true /* is_parent_frame_secure */);
+  RemoteProviderInfo remote_info_1 = SetupProviderHostInfoPtrs(&host_info_1);
+  RemoteProviderInfo remote_info_2 = SetupProviderHostInfoPtrs(&host_info_2);
+  RemoteProviderInfo remote_info_3 = SetupProviderHostInfoPtrs(&host_info_3);
+
+  // PlzNavigate
+  std::unique_ptr<ServiceWorkerNavigationHandleCore> navigation_handle_core;
+  if (IsBrowserSideNavigationEnabled()) {
+    navigation_handle_core =
+        CreateNavigationHandleCore(helper_->context_wrapper());
+    ASSERT_TRUE(navigation_handle_core);
+    // ProviderHost should be created before OnProviderCreated.
+    navigation_handle_core->DidPreCreateProviderHost(
+        ServiceWorkerProviderHost::PreCreateNavigationHost(
+            helper_->context()->AsWeakPtr(), true /* are_ancestors_secure */,
+            base::Callback<WebContents*(void)>()));
+  }
+
+  dispatcher_host_->OnProviderCreated(std::move(host_info_1));
   EXPECT_TRUE(context()->GetProviderHost(process_id, kProviderId));
 
   // Two with the same ID should be seen as a bad message.
-  dispatcher_host_->OnProviderCreated(ServiceWorkerProviderHostInfo(
-      kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
-      true /* is_parent_frame_secure */));
+  dispatcher_host_->OnProviderCreated(std::move(host_info_2));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 
-  dispatcher_host_->OnProviderDestroyed(kProviderId);
+  // Releasing the interface pointer destroys the counterpart.
+  remote_info_1.host_ptr.reset();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(context()->GetProviderHost(process_id, kProviderId));
 
-  // Destroying an ID that does not exist warrants a bad message.
-  dispatcher_host_->OnProviderDestroyed(kProviderId);
-  EXPECT_EQ(2, dispatcher_host_->bad_messages_received_count_);
+  // PlzNavigate
+  // Prepare another navigation handle to create another provider host.
+  if (IsBrowserSideNavigationEnabled()) {
+    navigation_handle_core =
+        CreateNavigationHandleCore(helper_->context_wrapper());
+    ASSERT_TRUE(navigation_handle_core);
+    // ProviderHost should be created before OnProviderCreated.
+    navigation_handle_core->DidPreCreateProviderHost(
+        ServiceWorkerProviderHost::PreCreateNavigationHost(
+            helper_->context()->AsWeakPtr(), true /* are_ancestors_secure */,
+            base::Callback<WebContents*(void)>()));
+  }
 
   // Deletion of the dispatcher_host should cause providers for that
   // process to get deleted as well.
-  dispatcher_host_->OnProviderCreated(ServiceWorkerProviderHostInfo(
-      kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
-      true /* is_parent_frame_secure */));
+  dispatcher_host_->OnProviderCreated(std::move(host_info_3));
   EXPECT_TRUE(context()->GetProviderHost(process_id, kProviderId));
   EXPECT_TRUE(dispatcher_host_->HasOneRef());
   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));
@@ skipping 114 matching lines @@
   // 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()));
 
   // 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->OnProviderCreated(ServiceWorkerProviderHostInfo(
-      provider_id, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
-      true /* is_parent_frame_secure */));
+  ServiceWorkerProviderHostInfo host_info(provider_id, MSG_ROUTING_NONE,
+                                          SERVICE_WORKER_PROVIDER_FOR_WINDOW,
+                                          true /* is_parent_frame_secure */);
+  ServiceWorkerRemoteProviderEndpoint remote_endpoint;
+  remote_endpoint.BindWithProviderHostInfo(&host_info);
+  new_dispatcher_host->OnProviderCreated(std::move(host_info));
   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);
   SetUpRegistration(pattern, script_url);
 
@@ skipping 148 matching lines @@
   const int kFetchEventId = 91;  // Dummy value
   dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_FetchEventResponse(
       version_->embedded_worker()->embedded_worker_id(), kFetchEventId,
       ServiceWorkerResponse(), base::Time::Now()));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, dispatcher_host_->bad_messages_received_count_);
 }
 
 }  // namespace content