Worker: Remove cross-thread PostTask functions from WorkerLoaderProxy

third_party/WebKit/Source/core/workers/WorkerThreadTest.cpp

 // Copyright 2015 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/workers/WorkerThread.h"
 
 #include <memory>
 #include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThreadTestHelper.h"
 #include "platform/WaitableEvent.h"
@@ skipping 49 matching lines @@
   waitable_event->Wait();
 }
 
 }  // namespace
 
 class WorkerThreadTest : public ::testing::Test {
  public:
   WorkerThreadTest() {}
 
   void SetUp() override {
-    loader_proxy_provider_ = WTF::MakeUnique<MockWorkerLoaderProxyProvider>();
+    loader_proxy_provider_ = WTF::MakeUnique<WorkerLoaderProxyProvider>();
     reporting_proxy_ = WTF::MakeUnique<MockWorkerReportingProxy>();
     security_origin_ =
         SecurityOrigin::Create(KURL(kParsedURLString, "http://fake.url/"));
     worker_thread_ = WTF::WrapUnique(new WorkerThreadForTest(
         loader_proxy_provider_.get(), *reporting_proxy_));
     lifecycle_observer_ = new MockWorkerThreadLifecycleObserver(
         worker_thread_->GetWorkerThreadLifecycleContext());
   }
 
   void TearDown() override {
@@ skipping 55 matching lines @@
     EXPECT_CALL(*reporting_proxy_, WillEvaluateWorkerScriptMock(_, _)).Times(1);
     EXPECT_CALL(*reporting_proxy_, DidEvaluateWorkerScript(false)).Times(1);
     EXPECT_CALL(*reporting_proxy_, WillDestroyWorkerGlobalScope()).Times(1);
     EXPECT_CALL(*reporting_proxy_, DidTerminateWorkerThread()).Times(1);
     EXPECT_CALL(*lifecycle_observer_, ContextDestroyed(_)).Times(1);
   }
 
   ExitCode GetExitCode() { return worker_thread_->GetExitCodeForTesting(); }
 
   RefPtr<SecurityOrigin> security_origin_;
-  std::unique_ptr<MockWorkerLoaderProxyProvider> loader_proxy_provider_;
+  std::unique_ptr<WorkerLoaderProxyProvider> loader_proxy_provider_;
   std::unique_ptr<MockWorkerReportingProxy> reporting_proxy_;
   std::unique_ptr<WorkerThreadForTest> worker_thread_;
   Persistent<MockWorkerThreadLifecycleObserver> lifecycle_observer_;
 };
 
 TEST_F(WorkerThreadTest, ShouldScheduleToTerminateExecution) {
   using ThreadState = WorkerThread::ThreadState;
   MutexLocker dummy_lock(worker_thread_->thread_state_mutex_);
 
   EXPECT_EQ(ThreadState::kNotStarted, worker_thread_->thread_state_);
@@ skipping 223 matching lines @@
 
   // Resume the debugger task. Shutdown starts after that.
   waitable_event.Signal();
   worker_thread_->WaitForShutdownForTesting();
   EXPECT_EQ(ExitCode::kGracefullyTerminated, GetExitCode());
 }
 
 // TODO(nhiroki): Add tests for terminateAndWaitForAllWorkers.
 
 }  // namespace blink