S13nServiceWorker: Add tests for ServiceWorkerScriptLoaderFactory

This CL adds three tests which basically correspond to
ServiceWorkerContextRequestHandlerTest.ErrorCases.

Bug: 860361
Change-Id: I57bca1d4ad53ffa53e45fd6b3e340d678133a856
Reviewed-on: https://chromium-review.googlesource.com/1146539Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Commit-Queue: Kenichi Ishibashi <bashi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#577437}

content/browser/service_worker/service_worker_script_loader_factory.h

@@ -6,6 +6,7 @@
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_SCRIPT_LOADER_FACTORY_H_
 
 #include "base/macros.h"
+#include "content/common/content_export.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/network/public/mojom/url_loader_factory.mojom.h"
 
@@ -30,7 +31,7 @@ class ServiceWorkerProviderHost;
 //
 // This factory creates either a ServiceWorkerNewScriptLoader or a
 // ServiceWorkerInstalledScriptLoader to load a script.
-class ServiceWorkerScriptLoaderFactory
+class CONTENT_EXPORT ServiceWorkerScriptLoaderFactory
     : public network::mojom::URLLoaderFactory {
  public:
   // |loader_factory| is used to load scripts. Typically

content/browser/service_worker/service_worker_script_loader_factory_unittest.cc

+// Copyright 2018 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_script_loader_factory.h"
+
+#include "base/run_loop.h"
+#include "base/test/scoped_feature_list.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_registration.h"
+#include "content/browser/service_worker/service_worker_test_utils.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "net/http/http_util.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
+#include "services/network/test/test_url_loader_client.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/public/common/features.h"
+
+namespace content {
+
+namespace {
+
+// A URLLoaderFactory that returns 200 OK with an empty javascript to any
+// request.
+// TODO(bashi): Avoid duplicated MockNetworkURLLoaderFactory. This is almost the
+// same as EmbeddedWorkerTestHelper::MockNetworkURLLoaderFactory.
+class MockNetworkURLLoaderFactory final
+    : public network::mojom::URLLoaderFactory {
+ public:
+  MockNetworkURLLoaderFactory() = default;
+
+  // network::mojom::URLLoaderFactory implementation.
+  void CreateLoaderAndStart(network::mojom::URLLoaderRequest request,
+                            int32_t routing_id,
+                            int32_t request_id,
+                            uint32_t options,
+                            const network::ResourceRequest& url_request,
+                            network::mojom::URLLoaderClientPtr client,
+                            const net::MutableNetworkTrafficAnnotationTag&
+                                traffic_annotation) override {
+    const std::string headers =
+        "HTTP/1.1 200 OK\n"
+        "Content-Type: application/javascript\n\n";
+    net::HttpResponseInfo info;
+    info.headers = new net::HttpResponseHeaders(
+        net::HttpUtil::AssembleRawHeaders(headers.c_str(), headers.length()));
+    network::ResourceResponseHead response;
+    response.headers = info.headers;
+    response.headers->GetMimeType(&response.mime_type);
+    client->OnReceiveResponse(response);
+
+    const std::string body = "/*this body came from the network*/";
+    uint32_t bytes_written = body.size();
+    mojo::DataPipe data_pipe;
+    data_pipe.producer_handle->WriteData(body.data(), &bytes_written,
+                                         MOJO_WRITE_DATA_FLAG_ALL_OR_NONE);
+    client->OnStartLoadingResponseBody(std::move(data_pipe.consumer_handle));
+
+    network::URLLoaderCompletionStatus status;
+    status.error_code = net::OK;
+    client->OnComplete(status);
+  }
+
+  void Clone(network::mojom::URLLoaderFactoryRequest request) override {
+    bindings_.AddBinding(this, std::move(request));
+  }
+
+ private:
+  mojo::BindingSet<network::mojom::URLLoaderFactory> bindings_;
+  DISALLOW_COPY_AND_ASSIGN(MockNetworkURLLoaderFactory);
+};
+
+}  // namespace
+
+class ServiceWorkerScriptLoaderFactoryTest : public testing::Test {
+ public:
+  ServiceWorkerScriptLoaderFactoryTest()
+      : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
+  ~ServiceWorkerScriptLoaderFactoryTest() override = default;
+
+  void SetUp() override {
+    scoped_feature_list_.InitAndEnableFeature(
+        blink::features::kServiceWorkerServicification);
+
+    helper_ = std::make_unique<EmbeddedWorkerTestHelper>(base::FilePath());
+    ServiceWorkerContextCore* context = helper_->context();
+    context->storage()->LazyInitializeForTest(base::DoNothing());
+    base::RunLoop().RunUntilIdle();
+
+    scope_ = GURL("https://host/scope");
+
+    blink::mojom::ServiceWorkerRegistrationOptions options;
+    options.scope = scope_;
+    registration_ = base::MakeRefCounted<ServiceWorkerRegistration>(
+        options, 1L /* registration_id */, context->AsWeakPtr());
+    version_ = base::MakeRefCounted<ServiceWorkerVersion>(
+        registration_.get(), GURL("https://host/script.js"),
+        context->storage()->NewVersionId(), context->AsWeakPtr());
+
+    std::unique_ptr<ServiceWorkerProviderHost> provider_host =
+        CreateProviderHostForServiceWorkerContext(
+            helper_->mock_render_process_id(),
+            true /* is_parent_frame_secure */, version_.get(),
+            context->AsWeakPtr(), &remote_endpoint_);
+    provider_host_ = provider_host->AsWeakPtr();
+    context->AddProviderHost(std::move(provider_host));
+
+    network_loader_factory_ = std::make_unique<MockNetworkURLLoaderFactory>();
+    helper_->SetNetworkFactory(network_loader_factory_.get());
+
+    factory_ = std::make_unique<ServiceWorkerScriptLoaderFactory>(
+        helper_->context()->AsWeakPtr(), provider_host_,
+        helper_->url_loader_factory_getter()->GetNetworkFactory());
+  }
+
+ protected:
+  network::mojom::URLLoaderPtr CreateTestLoaderAndStart(
+      network::TestURLLoaderClient* client) {
+    network::mojom::URLLoaderPtr loader;
+    network::ResourceRequest resource_request;
+    resource_request.url = scope_;
+    resource_request.resource_type = RESOURCE_TYPE_SERVICE_WORKER;
+    factory_->CreateLoaderAndStart(
+        mojo::MakeRequest(&loader), 0 /* routing_id */, 0 /* request_id */,
+        network::mojom::kURLLoadOptionNone, resource_request,
+        client->CreateInterfacePtr(),
+        net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
+    return loader;
+  }
+
+  base::test::ScopedFeatureList scoped_feature_list_;
+  TestBrowserThreadBundle browser_thread_bundle_;
+  std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
+  GURL scope_;
+  scoped_refptr<ServiceWorkerRegistration> registration_;
+  scoped_refptr<ServiceWorkerVersion> version_;
+  base::WeakPtr<ServiceWorkerProviderHost> provider_host_;
+  ServiceWorkerRemoteProviderEndpoint remote_endpoint_;
+  std::unique_ptr<MockNetworkURLLoaderFactory> network_loader_factory_;
+  std::unique_ptr<ServiceWorkerScriptLoaderFactory> factory_;
+};
+
+TEST_F(ServiceWorkerScriptLoaderFactoryTest, Success) {
+  network::TestURLLoaderClient client;
+  network::mojom::URLLoaderPtr loader = CreateTestLoaderAndStart(&client);
+  client.RunUntilComplete();
+  EXPECT_EQ(net::OK, client.completion_status().error_code);
+}
+
+TEST_F(ServiceWorkerScriptLoaderFactoryTest, Redundant) {
+  version_->SetStatus(ServiceWorkerVersion::REDUNDANT);
+
+  network::TestURLLoaderClient client;
+  network::mojom::URLLoaderPtr loader = CreateTestLoaderAndStart(&client);
+  client.RunUntilComplete();
+  EXPECT_EQ(net::ERR_ABORTED, client.completion_status().error_code);
+}
+
+TEST_F(ServiceWorkerScriptLoaderFactoryTest, NoProviderHost) {
+  helper_->context()->RemoveProviderHost(helper_->mock_render_process_id(),
+                                         provider_host_->provider_id());
+
+  network::TestURLLoaderClient client;
+  network::mojom::URLLoaderPtr loader = CreateTestLoaderAndStart(&client);
+  client.RunUntilComplete();
+  EXPECT_EQ(net::ERR_ABORTED, client.completion_status().error_code);
+}
+
+TEST_F(ServiceWorkerScriptLoaderFactoryTest, ContextDestroyed) {
+  helper_->ShutdownContext();
+  base::RunLoop().RunUntilIdle();
+
+  network::TestURLLoaderClient client;
+  network::mojom::URLLoaderPtr loader = CreateTestLoaderAndStart(&client);
+  client.RunUntilComplete();
+  EXPECT_EQ(net::ERR_ABORTED, client.completion_status().error_code);
+}
+
+}  // namespace content

content/test/BUILD.gn

@@ -1534,6 +1534,7 @@ test("content_unittests") {
     "../browser/service_worker/service_worker_read_from_cache_job_unittest.cc",
     "../browser/service_worker/service_worker_registration_unittest.cc",
     "../browser/service_worker/service_worker_request_handler_unittest.cc",
+    "../browser/service_worker/service_worker_script_loader_factory_unittest.cc",
     "../browser/service_worker/service_worker_storage_unittest.cc",
     "../browser/service_worker/service_worker_url_request_job_unittest.cc",
     "../browser/service_worker/service_worker_version_unittest.cc",