Add two interfaces for ServiceWorkerProviderContext/ProviderHost

content/browser/service_worker/service_worker_provider_host_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_provider_host.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 80 matching lines @@
         CreateProviderHostForWindow(helper_->mock_render_process_id(),
                                     next_provider_id_++,
                                     false /* is_parent_frame_secure */,
                                     helper_->context()->AsWeakPtr());
     ServiceWorkerProviderHost* host_raw = host.get();
     host->SetDocumentUrl(document_url);
     context_->AddProviderHost(std::move(host));
     return host_raw;
   }
 
+  ServiceWorkerProviderHost* CreateProviderHostWithMojo(
+      const GURL& document_url,
+      mojom::ServiceWorkerProviderHostAssociatedPtr* host_ptr,
+      mojom::ServiceWorkerProviderAssociatedPtr client_ptr) {
+    ServiceWorkerProviderHostInfo info(next_provider_id_++, MSG_ROUTING_NONE,
+                                       SERVICE_WORKER_PROVIDER_FOR_WINDOW,
+                                       true /* is_parent_frame_secure */);
+    info.host_request = mojo::MakeIsolatedRequest(host_ptr);
+    info.client_ptr_info = client_ptr.PassInterface();
+    std::unique_ptr<ServiceWorkerProviderHost> host =
+        ServiceWorkerProviderHost::Create(
+            helper_->mock_render_process_id(), std::move(info),
+            helper_->context()->AsWeakPtr(), nullptr);
+    ServiceWorkerProviderHost* host_raw = host.get();
+    host->SetDocumentUrl(document_url);
+    context_->AddProviderHost(std::move(host));
+    return host_raw;
+  }
+
   TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
   ServiceWorkerContextCore* context_;
   scoped_refptr<ServiceWorkerRegistration> registration1_;
   scoped_refptr<ServiceWorkerRegistration> registration2_;
   scoped_refptr<ServiceWorkerRegistration> registration3_;
   GURL script_url_;
   ServiceWorkerTestContentClient test_content_client_;
   TestContentBrowserClient test_content_browser_client_;
   ContentBrowserClient* old_content_browser_client_;
@@ skipping 106 matching lines @@
   EXPECT_TRUE(OriginCanAccessServiceWorkers(url));
   provider_host_secure_parent->SetDocumentUrl(url);
   EXPECT_TRUE(provider_host_secure_parent->IsContextSecureForServiceWorker());
 
   // Exceptional service worker scheme with insecure parent frame.
   provider_host_insecure_parent->SetDocumentUrl(url);
   EXPECT_FALSE(
       provider_host_insecure_parent->IsContextSecureForServiceWorker());
 }
 
+class MockServiceWorkerProvider : public mojom::ServiceWorkerProvider {
+ public:
+  MockServiceWorkerProvider(
+      mojom::ServiceWorkerProviderAssociatedRequest request)
+      : binding_(this, std::move(request)) {}
+  bool is_bound() const { return binding_.is_bound(); }
+
+ private:
+  mojo::AssociatedBinding<mojom::ServiceWorkerProvider> binding_;
+};
+
+TEST_F(ServiceWorkerProviderHostTest, RemoveProvider) {
+  // Prepare mojo pointers living on the renderer side.
+  mojom::ServiceWorkerProviderAssociatedPtr provider_client_ptr;
+  MockServiceWorkerProvider provider_client(
+      mojo::MakeIsolatedRequest(&provider_client_ptr));
+  mojom::ServiceWorkerProviderHostAssociatedPtr provider_host_ptr;
+
+  // Create a provider host connected with the renderer process.
+  ServiceWorkerProviderHost* provider_host = CreateProviderHostWithMojo(
+      GURL("https://www.example.com/example1.html"), &provider_host_ptr,
+      std::move(provider_client_ptr));
+  int process_id = provider_host->process_id();
+  int provider_id = provider_host->provider_id();
+  EXPECT_TRUE(context_->GetProviderHost(process_id, provider_id));
+
+  // Disconnect the mojo pipe from the renderer side.
+  provider_host_ptr.reset();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(context_->GetProviderHost(process_id, provider_id));
+}
+
 }  // namespace content