Worker: Remove cross-thread PostTask functions from WorkerLoaderProxy

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

 /*
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 47 matching lines @@
       WTF::MakeUnique<Vector<char>>(data_length);
   memcpy(buffer->data(), data, data_length);
   return buffer;
 }
 
 }  // namespace
 
 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()); }
 
   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 {
   TaskWithLocation(const WebTraceLocation& location,
                    std::unique_ptr<CrossThreadClosure> task)
       : location_(location), task_(std::move(task)) {}
   TaskWithLocation(TaskWithLocation&& task)
       : TaskWithLocation(task.location_, std::move(task.task_)) {}
   ~TaskWithLocation() = default;
 
@@ skipping 93 matching lines @@
 
 WorkerThreadableLoader::WorkerThreadableLoader(
     WorkerGlobalScope& worker_global_scope,
     ThreadableLoaderClient* client,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resource_loader_options,
     BlockingBehavior blocking_behavior)
     : 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),
       blocking_behavior_(blocking_behavior) {
   DCHECK(client);
 }
 
 void WorkerThreadableLoader::LoadResourceSynchronously(
     WorkerGlobalScope& worker_global_scope,
     const ResourceRequest& request,
@@ skipping 16 matching lines @@
     request.SetHTTPReferrer(SecurityPolicy::GenerateReferrer(
         worker_global_scope_->GetReferrerPolicy(), request.Url(),
         worker_global_scope_->OutgoingReferrer()));
   }
 
   DCHECK(!IsMainThread());
   RefPtr<WaitableEventWithTasks> event_with_tasks;
   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;
 
   event_with_tasks->Wait();
 
   if (event_with_tasks->IsAborted()) {
     // This thread is going to terminate.
     Cancel();
     return;
   }
 
   for (const auto& task : event_with_tasks->Take()) {
     // Store the program counter where the task is posted from, and alias
     // it to ensure it is stored in the crash dump.
     const void* program_counter = task.location_.program_counter();
     WTF::debug::Alias(&program_counter);
 
     (*task.task_)();
   }
 }
 
 void WorkerThreadableLoader::OverrideTimeout(
     unsigned long timeout_milliseconds) {
   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;
   }
 
   if (!client_)
     return;
 
   // If the client hasn't reached a termination state, then transition it
   // by sending a cancellation error.
   // Note: no more client callbacks will be done after this method -- the
   // clearClient() call ensures that.
   ResourceError error(String(), 0, String(), String());
   error.SetIsCancellation(true);
   DidFail(error);
   DCHECK(!client_);
 }
 
 void WorkerThreadableLoader::DidStart(
     MainThreadLoaderHolder* main_thread_loader_holder) {
   DCHECK(!IsMainThread());
   DCHECK(!main_thread_loader_holder_);
   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;
   }
 
   main_thread_loader_holder_ = main_thread_loader_holder;
 }
 
 void WorkerThreadableLoader::DidSendData(
     unsigned long long bytes_sent,
     unsigned long long total_bytes_to_be_sent) {
   DCHECK(!IsMainThread());
@@ skipping 99 matching lines @@
 }
 
 DEFINE_TRACE(WorkerThreadableLoader) {
   visitor->Trace(worker_global_scope_);
   ThreadableLoader::Trace(visitor);
 }
 
 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,
     const ResourceLoaderOptions& resource_loader_options,
     PassRefPtr<WaitableEventWithTasks> event_with_tasks) {
   DCHECK(IsMainThread());
   TaskForwarder* forwarder;
   ThreadableLoadingContext* loading_context =
       loader_proxy->GetThreadableLoadingContext();
   if (!loading_context)
     return;
   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);
   if (main_thread_loader_holder->WasContextDestroyedBeforeObserverCreation()) {
     // The thread is already terminating.
     forwarder->Abort();
     main_thread_loader_holder->forwarder_ = nullptr;
     return;
   }
   main_thread_loader_holder->worker_loader_ = worker_loader;
@@ skipping 212 matching lines @@
   DCHECK(IsMainThread());
   ResourceLoaderOptions resource_loader_options =
       original_resource_loader_options;
   resource_loader_options.request_initiator_context = kWorkerContext;
   main_thread_loader_ = DocumentThreadableLoader::Create(
       loading_context, this, options, resource_loader_options);
   main_thread_loader_->Start(ResourceRequest(request.get()));
 }
 
 }  // namespace blink