[WIP] off-main-thread loading

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/web_url_loader_impl.h"
+#include "content/common/frame_messages.h"
+#include "mojo/public/cpp/bindings/associated_binding.h"
+
+namespace content {
+
+namespace {
+
+class WorkerFetchContextImpl : public blink::WebWorkerFetchContext,
+                               public mojom::ServiceWorkerClient {
+ public:
+  WorkerFetchContextImpl(mojom::WorkerFetchContextFactoryPtrInfo factory_info,
+                         int service_worker_provider_id,
+                         int appcache_host_id,
+                         int parent_frame_id,
+                         bool parent_is_secure_context,
+                         bool parent_is_controlled_by_service_worker,
+                         base::SingleThreadTaskRunner* loading_task_runner,
+                         scoped_refptr<ThreadSafeSender> thread_safe_sender)
+      : binding_(this),
+        service_worker_provider_id_(service_worker_provider_id),
+        appcache_host_id_(appcache_host_id),
+        parent_frame_id_(parent_frame_id),
+        parent_is_secure_context_(parent_is_secure_context),
+        parent_is_controlled_by_service_worker_(
+            parent_is_controlled_by_service_worker),
+        resource_dispatcher_(
+            base::MakeUnique<ResourceDispatcher>(nullptr, loading_task_runner)),
+        thread_safe_sender_(std::move(thread_safe_sender)) {
+    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);
+  }
+
+  int64_t serviceWorkerID() const override { return controller_version_id_; }
+
+  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_);
+    extra_data->set_render_frame_id(parent_frame_id_);
+    // TODO(horo): Just checking the worker's origin is enough?
+    extra_data->set_initiated_in_secure_context(parent_is_secure_context_);
+    request.setExtraData(extra_data);
+    request.setAppCacheHostID(appcache_host_id_);
+
+    if (!IsControlledByServiceWorker() &&
+        request.getServiceWorkerMode() !=
+            blink::WebURLRequest::ServiceWorkerMode::None) {
+      request.setServiceWorkerMode(
+          blink::WebURLRequest::ServiceWorkerMode::Foreign);
+    }
+    // request.addHTTPOriginIfNeeded(blink::WebSecurityOrigin::createUnique());
+  }
+  void didRunContentWithCertificateErrors(const blink::WebURL& url) override {
+    Send(new FrameHostMsg_DidRunContentWithCertificateErrors(parent_frame_id_,
+                                                             url));
+  }
+  void didDisplayContentWithCertificateErrors(
+      const blink::WebURL& url) override {
+    Send(new FrameHostMsg_DidDisplayContentWithCertificateErrors(
+        parent_frame_id_, url));
+  }
+  bool Send(IPC::Message* message) {
+    return thread_safe_sender_->Send(message);
+  }
+
+ private:
+  mojo::AssociatedBinding<mojom::ServiceWorkerClient> binding_;
+  const int service_worker_provider_id_;
+  const int appcache_host_id_;
+  const int parent_frame_id_;
+  const int parent_is_secure_context_;
+  const bool parent_is_controlled_by_service_worker_;
+  std::unique_ptr<ResourceDispatcher> resource_dispatcher_;
+  scoped_refptr<ThreadSafeSender> thread_safe_sender_;
+  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)),
+      thread_safe_sender_(ChildThreadImpl::current()->thread_safe_sender()) {}
+
+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_), service_worker_provider_id_, appcache_host_id_,
+      parent_frame_id_, is_secure_context_, is_controlled_by_service_worker_,
+      loading_task_runner, std::move(thread_safe_sender_));
+}
+void WorkerFetchContextInfoImpl::setAppCacheHostID(int appcache_host_id) {
+  appcache_host_id_ = appcache_host_id;
+}
+void WorkerFetchContextInfoImpl::setParentFrameID(int parent_frame_id) {
+  parent_frame_id_ = parent_frame_id;
+}
+void WorkerFetchContextInfoImpl::setServiceWorkerProviderID(
+    int service_worker_provider_id) {
+  service_worker_provider_id_ = service_worker_provider_id;
+}
+void WorkerFetchContextInfoImpl::setIsSecureContext(bool is_secure_context) {
+  is_secure_context_ = is_secure_context;
+}
+void WorkerFetchContextInfoImpl::setIsControlledByServiceWorker(
+    bool contolled) {
+  is_controlled_by_service_worker_ = contolled;
+}
+void WorkerFetchContextInfoImpl::willSendRequest(blink::WebURLRequest&) {
+  NOTREACHED();
+}
+
+}  // namespace content