Worker: Remove cross-thread PostTask functions from WorkerLoaderProxy

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

Index: third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
diff --git a/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp b/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
index 0a5d0ddf6142c05a7761fafbf346a1222d479ddd..a63be36a66b406f015433902e069001c006419d0 100644
--- a/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
+++ b/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
@@ -65,8 +65,8 @@ std::unique_ptr<Vector<char>> CreateVectorFromMemoryRegion(
 class WorkerThreadableLoader::AsyncTaskForwarder final
     : public WorkerThreadableLoader::TaskForwarder {
  public:
-  explicit AsyncTaskForwarder(PassRefPtr<WorkerLoaderProxy> loader_proxy)
-      : loader_proxy_(std::move(loader_proxy)) {
+  explicit AsyncTaskForwarder(RefPtr<WebTaskRunner> worker_loading_task_runner)
+      : worker_loading_task_runner_(std::move(worker_loading_task_runner)) {
     DCHECK(IsMainThread());
   }
   ~AsyncTaskForwarder() override { DCHECK(IsMainThread()); }
@@ -74,18 +74,18 @@ class WorkerThreadableLoader::AsyncTaskForwarder final
   void ForwardTask(const WebTraceLocation& location,
                    std::unique_ptr<CrossThreadClosure> task) override {
     DCHECK(IsMainThread());
-    loader_proxy_->PostTaskToWorkerGlobalScope(location, std::move(task));
+    worker_loading_task_runner_->PostTask(location, std::move(task));
   }
   void ForwardTaskWithDoneSignal(
       const WebTraceLocation& location,
       std::unique_ptr<CrossThreadClosure> task) override {
     DCHECK(IsMainThread());
-    loader_proxy_->PostTaskToWorkerGlobalScope(location, std::move(task));
+    worker_loading_task_runner_->PostTask(location, std::move(task));
   }
   void Abort() override { DCHECK(IsMainThread()); }
 
  private:
-  RefPtr<WorkerLoaderProxy> loader_proxy_;
+  RefPtr<WebTaskRunner> worker_loading_task_runner_;
 };
 
 struct WorkerThreadableLoader::TaskWithLocation final {
@@ -199,6 +199,8 @@ WorkerThreadableLoader::WorkerThreadableLoader(
     : worker_global_scope_(&worker_global_scope),
       worker_loader_proxy_(
           worker_global_scope.GetThread()->GetWorkerLoaderProxy()),
+      parent_frame_task_runners_(
+          worker_global_scope.GetThread()->GetParentFrameTaskRunners()),
       client_(client),
       threadable_loader_options_(options),
       resource_loader_options_(resource_loader_options),
@@ -235,15 +237,19 @@ void WorkerThreadableLoader::Start(const ResourceRequest& original_request) {
   if (blocking_behavior_ == kLoadSynchronously)
     event_with_tasks = WaitableEventWithTasks::Create();
 
-  worker_loader_proxy_->PostTaskToLoader(
-      BLINK_FROM_HERE,
-      CrossThreadBind(
-          &MainThreadLoaderHolder::CreateAndStart,
-          WrapCrossThreadPersistent(this), worker_loader_proxy_,
-          WrapCrossThreadPersistent(worker_global_scope_->GetThread()
-                                        ->GetWorkerThreadLifecycleContext()),
-          request, threadable_loader_options_, resource_loader_options_,
-          event_with_tasks));
+  RefPtr<WebTaskRunner> worker_loading_task_runner = TaskRunnerHelper::Get(
+      TaskType::kUnspecedLoading, worker_global_scope_.Get());
+  parent_frame_task_runners_->Get(TaskType::kUnspecedLoading)
+      ->PostTask(
+          BLINK_FROM_HERE,
+          CrossThreadBind(&MainThreadLoaderHolder::CreateAndStart,
+                          WrapCrossThreadPersistent(this), worker_loader_proxy_,
+                          std::move(worker_loading_task_runner),
+                          WrapCrossThreadPersistent(
+                              worker_global_scope_->GetThread()
+                                  ->GetWorkerThreadLifecycleContext()),
+                          request, threadable_loader_options_,
+                          resource_loader_options_, event_with_tasks));
 
   if (blocking_behavior_ == kLoadAsynchronously)
     return;
@@ -271,18 +277,20 @@ void WorkerThreadableLoader::OverrideTimeout(
   DCHECK(!IsMainThread());
   if (!main_thread_loader_holder_)
     return;
-  worker_loader_proxy_->PostTaskToLoader(
-      BLINK_FROM_HERE,
-      CrossThreadBind(&MainThreadLoaderHolder::OverrideTimeout,
-                      main_thread_loader_holder_, timeout_milliseconds));
+  parent_frame_task_runners_->Get(TaskType::kUnspecedLoading)
+      ->PostTask(
+          BLINK_FROM_HERE,
+          CrossThreadBind(&MainThreadLoaderHolder::OverrideTimeout,
+                          main_thread_loader_holder_, timeout_milliseconds));
 }
 
 void WorkerThreadableLoader::Cancel() {
   DCHECK(!IsMainThread());
   if (main_thread_loader_holder_) {
-    worker_loader_proxy_->PostTaskToLoader(
-        BLINK_FROM_HERE, CrossThreadBind(&MainThreadLoaderHolder::Cancel,
-                                         main_thread_loader_holder_));
+    parent_frame_task_runners_->Get(TaskType::kUnspecedLoading)
+        ->PostTask(BLINK_FROM_HERE,
+                   CrossThreadBind(&MainThreadLoaderHolder::Cancel,
+                                   main_thread_loader_holder_));
     main_thread_loader_holder_ = nullptr;
   }
 
@@ -306,10 +314,11 @@ void WorkerThreadableLoader::DidStart(
   DCHECK(main_thread_loader_holder);
   if (!client_) {
     // The thread is terminating.
-    worker_loader_proxy_->PostTaskToLoader(
-        BLINK_FROM_HERE,
-        CrossThreadBind(&MainThreadLoaderHolder::Cancel,
-                        WrapCrossThreadPersistent(main_thread_loader_holder)));
+    parent_frame_task_runners_->Get(TaskType::kUnspecedLoading)
+        ->PostTask(BLINK_FROM_HERE,
+                   CrossThreadBind(
+                       &MainThreadLoaderHolder::Cancel,
+                       WrapCrossThreadPersistent(main_thread_loader_holder)));
     return;
   }
 
@@ -429,6 +438,7 @@ DEFINE_TRACE(WorkerThreadableLoader) {
 void WorkerThreadableLoader::MainThreadLoaderHolder::CreateAndStart(
     WorkerThreadableLoader* worker_loader,
     RefPtr<WorkerLoaderProxy> loader_proxy,
+    RefPtr<WebTaskRunner> worker_loading_task_runner,
     WorkerThreadLifecycleContext* worker_thread_lifecycle_context,
     std::unique_ptr<CrossThreadResourceRequestData> request,
     const ThreadableLoaderOptions& options,
@@ -443,7 +453,7 @@ void WorkerThreadableLoader::MainThreadLoaderHolder::CreateAndStart(
   if (event_with_tasks)
     forwarder = new SyncTaskForwarder(std::move(event_with_tasks));
   else
-    forwarder = new AsyncTaskForwarder(std::move(loader_proxy));
+    forwarder = new AsyncTaskForwarder(std::move(worker_loading_task_runner));
 
   MainThreadLoaderHolder* main_thread_loader_holder =
       new MainThreadLoaderHolder(forwarder, worker_thread_lifecycle_context);