Implement the infrastructure of creating WorkerFetchContext in worker global scope.

content/renderer/service_worker/worker_fetch_context_info_impl.cc

+// Copyright 2017 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/renderer/service_worker/worker_fetch_context_info_impl.h"
+
+#include "content/child/child_thread_impl.h"
+#include "content/child/request_extra_data.h"
+#include "content/child/resource_dispatcher.h"
+#include "content/child/thread_safe_sender.h"
+#include "content/child/web_url_loader_impl.h"
+#include "content/common/frame_messages.h"
+#include "mojo/public/cpp/bindings/associated_binding.h"
+#include "third_party/WebKit/public/platform/WebWorkerFetchContext.h"
+#include "third_party/WebKit/public/platform/WebWorkerFetchContextInfo.h"
+
+namespace content {
+
+namespace {
+
+class WorkerFetchContextImpl : public blink::WebWorkerFetchContext,
+                               public mojom::ServiceWorkerClient {
+ public:
+  WorkerFetchContextImpl(mojom::WorkerFetchContextFactoryPtrInfo factory_info,
+                         blink::WebWorkerFetchContextInfo* info,
+                         base::SingleThreadTaskRunner* loading_task_runner)
+      : binding_(this),
+        service_worker_provider_id_(info->GetServiceWorkerProviderID()),
+        parent_is_controlled_by_service_worker_(
+            info->IsControlledByServiceWorker()),
+        resource_dispatcher_(
+            base::MakeUnique<ResourceDispatcher>(nullptr,
+                                                 loading_task_runner)) {
+    factory_.Bind(std::move(factory_info));
+    mojom::ServiceWorkerClientAssociatedPtrInfo ptr_info;
+    binding_.Bind(&ptr_info);
+    factory_->CreateWorkerFetchContext(mojo::MakeRequest(&url_loader_factory_),
+                                       std::move(ptr_info),
+                                       service_worker_provider_id_);
+  }
+  ~WorkerFetchContextImpl() override {}
+
+  void SetControllerServiceWorker(int64_t controller_version_id) override {
+    controller_version_id_ = controller_version_id;
+  }
+
+  bool IsControlledByServiceWorker() const override {
+    return parent_is_controlled_by_service_worker_ ||
+           (controller_version_id_ != kInvalidServiceWorkerVersionId);
+  }
+
+  blink::WebURLLoader* CreateURLLoader() override {
+    return new content::WebURLLoaderImpl(resource_dispatcher_.get(),
+                                         url_loader_factory_.get());
+  }
+
+  void WillSendRequest(blink::WebURLRequest& request) override {
+    RequestExtraData* extra_data = new RequestExtraData();
+    extra_data->set_service_worker_provider_id(service_worker_provider_id_);
+    request.SetExtraData(extra_data);
+
+    if (!IsControlledByServiceWorker() &&
+        request.GetServiceWorkerMode() !=
+            blink::WebURLRequest::ServiceWorkerMode::kNone) {
+      request.SetServiceWorkerMode(
+          blink::WebURLRequest::ServiceWorkerMode::kForeign);
+    }
+  }
+
+ private:
+  mojo::AssociatedBinding<mojom::ServiceWorkerClient> binding_;
+  const int service_worker_provider_id_;
+  const bool parent_is_controlled_by_service_worker_;
+  std::unique_ptr<ResourceDispatcher> resource_dispatcher_;
+  int controller_version_id_ = kInvalidServiceWorkerVersionId;
+  mojom::WorkerFetchContextFactoryPtr factory_;
+  mojom::URLLoaderFactoryAssociatedPtr url_loader_factory_;
+};
+
+}  // namespace
+
+WorkerFetchContextInfoImpl::WorkerFetchContextInfoImpl(
+    mojom::WorkerFetchContextFactoryPtrInfo factory_info)
+    : factory_info_(std::move(factory_info)) {}
+
+WorkerFetchContextInfoImpl::~WorkerFetchContextInfoImpl() {}
+
+std::unique_ptr<blink::WebWorkerFetchContext>
+WorkerFetchContextInfoImpl::CreateContext(
+    base::SingleThreadTaskRunner* loading_task_runner) {
+  DCHECK(factory_info_.is_valid());
+  return base::MakeUnique<WorkerFetchContextImpl>(std::move(factory_info_),
+                                                  this, loading_task_runner);
+}
+
+}  // namespace content