Worker: Remove cross-thread PostTask functions from WorkerLoaderProxy

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

 // Copyright 2016 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/ThreadableLoader.h"
 
 #include <memory>
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/loader/DocumentThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
@@ skipping 163 matching lines @@
                                          public WorkerLoaderProxyProvider {
  public:
   WorkerThreadableLoaderTestHelper()
       : dummy_page_holder_(DummyPageHolder::Create(IntSize(1, 1))) {}
 
   void CreateLoader(
       ThreadableLoaderClient* client,
       CrossOriginRequestPolicy cross_origin_request_policy) override {
     std::unique_ptr<WaitableEvent> completion_event =
         WTF::MakeUnique<WaitableEvent>();
-    PostTaskToWorkerGlobalScope(
+    worker_loading_task_runner_->PostTask(
         BLINK_FROM_HERE,
         CrossThreadBind(&WorkerThreadableLoaderTestHelper::WorkerCreateLoader,
                         CrossThreadUnretained(this),
                         CrossThreadUnretained(client),
                         CrossThreadUnretained(completion_event.get()),
                         cross_origin_request_policy));
     completion_event->Wait();
   }
 
   void StartLoader(const ResourceRequest& request) override {
     std::unique_ptr<WaitableEvent> completion_event =
         WTF::MakeUnique<WaitableEvent>();
-    PostTaskToWorkerGlobalScope(
+    worker_loading_task_runner_->PostTask(
         BLINK_FROM_HERE,
         CrossThreadBind(&WorkerThreadableLoaderTestHelper::WorkerStartLoader,
                         CrossThreadUnretained(this),
                         CrossThreadUnretained(completion_event.get()),
                         request));
     completion_event->Wait();
   }
 
   // Must be called on the worker thread.
   void CancelLoader() override {
@@ skipping 16 matching lines @@
     loader_ = nullptr;
   }
 
   Checkpoint& GetCheckpoint() override { return checkpoint_; }
 
   void CallCheckpoint(int n) override {
     testing::RunPendingTasks();
 
     std::unique_ptr<WaitableEvent> completion_event =
         WTF::MakeUnique<WaitableEvent>();
-    PostTaskToWorkerGlobalScope(
+    worker_loading_task_runner_->PostTask(
         BLINK_FROM_HERE,
         CrossThreadBind(&WorkerThreadableLoaderTestHelper::WorkerCallCheckpoint,
                         CrossThreadUnretained(this),
                         CrossThreadUnretained(completion_event.get()), n));
     completion_event->Wait();
   }
 
   void OnSetUp() override {
     reporting_proxy_ = WTF::MakeUnique<WorkerReportingProxy>();
     security_origin_ = GetDocument().GetSecurityOrigin();
     parent_frame_task_runners_ =
         ParentFrameTaskRunners::Create(&dummy_page_holder_->GetFrame());
     worker_thread_ =
         WTF::WrapUnique(new WorkerThreadForTest(this, *reporting_proxy_));
     loading_context_ = ThreadableLoadingContext::Create(GetDocument());
 
     worker_thread_->StartWithSourceCode(security_origin_.Get(),
                                         "//fake source code",
                                         parent_frame_task_runners_.Get());
     worker_thread_->WaitForInit();
+    worker_loading_task_runner_ =
+        TaskRunnerHelper::Get(TaskType::kUnspecedLoading, worker_thread_.get());
   }
 
   void OnServeRequests() override { testing::RunPendingTasks(); }
 
   void OnTearDown() override {
-    PostTaskToWorkerGlobalScope(
+    worker_loading_task_runner_->PostTask(
         BLINK_FROM_HERE,
         CrossThreadBind(&WorkerThreadableLoaderTestHelper::ClearLoader,
                         CrossThreadUnretained(this)));
     WaitableEvent event;
-    PostTaskToWorkerGlobalScope(
+    worker_loading_task_runner_->PostTask(
         BLINK_FROM_HERE,
         CrossThreadBind(&WaitableEvent::Signal, CrossThreadUnretained(&event)));
     event.Wait();
     worker_thread_->TerminateAndWait();
 
     // Needed to clean up the things on the main thread side and
     // avoid Resource leaks.
     testing::RunPendingTasks();
 
     worker_thread_->GetWorkerLoaderProxy()->DetachProvider(this);
@@ skipping 37 matching lines @@
   }
 
   void WorkerCallCheckpoint(WaitableEvent* event, int n) {
     DCHECK(worker_thread_);
     DCHECK(worker_thread_->IsCurrentThread());
     checkpoint_.Call(n);
     event->Signal();
   }
 
   // WorkerLoaderProxyProvider methods.
-  void PostTaskToLoader(
-      const WebTraceLocation& location,
-      std::unique_ptr<WTF::CrossThreadClosure> task) override {
-    DCHECK(worker_thread_);
-    DCHECK(worker_thread_->IsCurrentThread());
-    parent_frame_task_runners_->Get(TaskType::kNetworking)
-        ->PostTask(BLINK_FROM_HERE, std::move(task));
-  }
-
-  void PostTaskToWorkerGlobalScope(
-      const WebTraceLocation& location,
-      std::unique_ptr<WTF::CrossThreadClosure> task) override {
-    DCHECK(worker_thread_);
-    TaskRunnerHelper::Get(TaskType::kNetworking, worker_thread_.get())
-        ->PostTask(location, std::move(task));
-  }
-
   ThreadableLoadingContext* GetThreadableLoadingContext() override {
     return loading_context_.Get();
   }
 
   RefPtr<SecurityOrigin> security_origin_;
   std::unique_ptr<WorkerReportingProxy> reporting_proxy_;
   std::unique_ptr<WorkerThreadForTest> worker_thread_;
 
   std::unique_ptr<DummyPageHolder> dummy_page_holder_;
   // Accessed cross-thread when worker thread posts tasks to the parent.
   CrossThreadPersistent<ParentFrameTaskRunners> parent_frame_task_runners_;
+  RefPtr<WebTaskRunner> worker_loading_task_runner_;
   Checkpoint checkpoint_;
   // |m_loader| must be touched only from the worker thread only.
   CrossThreadPersistent<ThreadableLoader> loader_;
 
   Persistent<ThreadableLoadingContext> loading_context_;
 };
 
 class ThreadableLoaderTest
     : public ::testing::TestWithParam<ThreadableLoaderToTest> {
  public:
@@ skipping 522 matching lines @@
   // test is not saying that didFailAccessControlCheck should be dispatched
   // synchronously, but is saying that even when a response is served
   // synchronously it should not lead to a crash.
   StartLoader(KURL(KURL(), "about:blank"));
   CallCheckpoint(2);
 }
 
 }  // namespace
 
 }  // namespace blink