[WIP] off-main-thread loading

third_party/WebKit/Source/core/loader/ThreadableLoadingContext.cpp

 // 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 "core/loader/ThreadableLoadingContext.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/TaskRunnerHelper.h"
+#include "core/loader/WorkerFetchContext.h"
+#include "core/workers/WorkerGlobalScope.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 
 namespace blink {
 
 class DocumentThreadableLoadingContext final : public ThreadableLoadingContext {
  public:
   explicit DocumentThreadableLoadingContext(Document& document)
       : m_document(&document) {}
 
   ~DocumentThreadableLoadingContext() override = default;
@@ skipping 42 matching lines @@
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     visitor->trace(m_document);
     ThreadableLoadingContext::trace(visitor);
   }
 
  private:
   Member<Document> m_document;
 };
 
+class WorkerThreadableLoadingContext : public ThreadableLoadingContext {
+ public:
+  explicit WorkerThreadableLoadingContext(WorkerGlobalScope& workerGlobalScope)
+      : m_workerGlobalScope(&workerGlobalScope),
+        m_fetchContext(WorkerFetchContext::from(workerGlobalScope)) {}
+
+  ~WorkerThreadableLoadingContext() override = default;
+
+  bool isContextThread() const override {
+    DCHECK(m_fetchContext);
+    DCHECK(m_workerGlobalScope);
+    return m_workerGlobalScope->isContextThread();
+  }
+
+  ResourceFetcher* getResourceFetcher() override {
+    DCHECK(isContextThread());
+    return m_fetchContext->getResourceFetcher();
+  }
+
+  SecurityOrigin* getSecurityOrigin() override {
+    DCHECK(isContextThread());
+    return m_workerGlobalScope->getSecurityOrigin();
+  }
+
+  bool isSecureContext() const override {
+    DCHECK(isContextThread());
+    String errorMessage;
+    return m_workerGlobalScope->isSecureContext(errorMessage);
+  }
+
+  KURL firstPartyForCookies() const override {
+    DCHECK(isContextThread());
+    // TODO
+    return m_workerGlobalScope->url();
+  }
+
+  String userAgent() const override {
+    DCHECK(isContextThread());
+    return m_workerGlobalScope->userAgent();
+  }
+
+  Document* getLoadingDocument() override { return nullptr; }
+
+  RefPtr<WebTaskRunner> getTaskRunner(TaskType type) override {
+    switch (type) {
+      case TaskType::Timer:
+        return m_fetchContext->timerTaskRunner();
+      case TaskType::UnspecedLoading:
+      case TaskType::Networking:
+        return m_fetchContext->loadingTaskRunner();
+      default:
+        return TaskRunnerHelper::get(type, getLoadingDocument());
+    }
+  }
+
+  void recordUseCount(UseCounter::Feature feature) override {
+    UseCounter::count(m_workerGlobalScope, feature);
+  }
+
+  DEFINE_INLINE_VIRTUAL_TRACE() {
+    visitor->trace(m_fetchContext);
+    visitor->trace(m_workerGlobalScope);
+    ThreadableLoadingContext::trace(visitor);
+  }
+
+ private:
+  Member<WorkerGlobalScope> m_workerGlobalScope;
+  Member<WorkerFetchContext> m_fetchContext;
+};
+
 ThreadableLoadingContext* ThreadableLoadingContext::create(Document& document) {
   // For now this is the only default implementation.
   return new DocumentThreadableLoadingContext(document);
 }
 
+ThreadableLoadingContext* ThreadableLoadingContext::create(
+    WorkerGlobalScope& workerGlobalScope) {
+  return new WorkerThreadableLoadingContext(workerGlobalScope);
+}
+
 }  // namespace blink