test all

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)
       : document_(&document) {}
 
   ~DocumentThreadableLoadingContext() override = default;
@@ skipping 40 matching lines @@
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     visitor->Trace(document_);
     ThreadableLoadingContext::Trace(visitor);
   }
 
  private:
   Member<Document> document_;
 };
 
+class WorkerThreadableLoadingContext : public ThreadableLoadingContext {
+ public:
+  explicit WorkerThreadableLoadingContext(
+      WorkerGlobalScope& worker_global_scope)
+      : worker_global_scope_(&worker_global_scope),
+        fetch_context_(worker_global_scope.FetchContext()) {}
+
+  ~WorkerThreadableLoadingContext() override = default;
+
+  bool IsContextThread() const override {
+    DCHECK(fetch_context_);
+    DCHECK(worker_global_scope_);
+    return worker_global_scope_->IsContextThread();
+  }
+
+  ResourceFetcher* GetResourceFetcher() override {
+    DCHECK(IsContextThread());
+    return fetch_context_->GetResourceFetcher();
+  }
+
+  SecurityOrigin* GetSecurityOrigin() override {
+    DCHECK(IsContextThread());
+    return worker_global_scope_->GetSecurityOrigin();
+  }
+
+  bool IsSecureContext() const override {
+    DCHECK(IsContextThread());
+    String errorMessage;
+    return worker_global_scope_->IsSecureContext(errorMessage);
+  }
+
+  KURL FirstPartyForCookies() const override {
+    DCHECK(IsContextThread());
+    // TODO
+    return worker_global_scope_->Url();
+  }
+
+  String UserAgent() const override {
+    DCHECK(IsContextThread());
+    return worker_global_scope_->UserAgent();
+  }
+
+  Document* GetLoadingDocument() override { return nullptr; }
+
+  RefPtr<WebTaskRunner> GetTaskRunner(TaskType type) override {
+    switch (type) {
+      case TaskType::kTimer:
+        return fetch_context_->TimerTaskRunner();
+      case TaskType::kUnspecedLoading:
+      case TaskType::kNetworking:
+        return fetch_context_->LoadingTaskRunner();
+      default:
+        return TaskRunnerHelper::Get(type, GetLoadingDocument());
+    }
+  }
+
+  void RecordUseCount(UseCounter::Feature feature) override {
+    UseCounter::Count(worker_global_scope_, feature);
+  }
+
+  DEFINE_INLINE_VIRTUAL_TRACE() {
+    visitor->Trace(fetch_context_);
+    visitor->Trace(worker_global_scope_);
+    ThreadableLoadingContext::Trace(visitor);
+  }
+
+ private:
+  Member<WorkerGlobalScope> worker_global_scope_;
+  Member<WorkerFetchContext> fetch_context_;
+};
+
 ThreadableLoadingContext* ThreadableLoadingContext::Create(Document& document) {
   // For now this is the only default implementation.
   return new DocumentThreadableLoadingContext(document);
 }
 
+ThreadableLoadingContext* ThreadableLoadingContext::Create(
+    WorkerGlobalScope& worker_global_scope) {
+  return new WorkerThreadableLoadingContext(worker_global_scope);
+}
+
 }  // namespace blink