Worker: Stop using ExecutionContextTask on WorkerLoaderProxy::postTaskToWorkerGlobalScope

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 "core/dom/ExecutionContextTask.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceLoaderOptions.h"
 #include "core/loader/DocumentThreadableLoader.h"
@@ skipping 12 matching lines @@
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebURLLoadTiming.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
 #include "public/platform/WebURLResponse.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/Assertions.h"
+#include "wtf/Functional.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
 using ::testing::_;
 using ::testing::InSequence;
@@ skipping 128 matching lines @@
   WorkerThreadableLoaderTestHelper()
       : m_dummyPageHolder(DummyPageHolder::create(IntSize(1, 1))) {}
 
   void createLoader(
       ThreadableLoaderClient* client,
       CrossOriginRequestPolicy crossOriginRequestPolicy) override {
     std::unique_ptr<WaitableEvent> completionEvent =
         WTF::makeUnique<WaitableEvent>();
     postTaskToWorkerGlobalScope(
         BLINK_FROM_HERE,
-        createCrossThreadTask(
-            &WorkerThreadableLoaderTestHelper::workerCreateLoader,
-            crossThreadUnretained(this), crossThreadUnretained(client),
-            crossThreadUnretained(completionEvent.get()),
-            crossOriginRequestPolicy));
+        crossThreadBind(&WorkerThreadableLoaderTestHelper::workerCreateLoader,
+                        crossThreadUnretained(this),
+                        crossThreadUnretained(client),
+                        crossThreadUnretained(completionEvent.get()),
+                        crossOriginRequestPolicy));
     completionEvent->wait();
   }
 
   void startLoader(const ResourceRequest& request) override {
     std::unique_ptr<WaitableEvent> completionEvent =
         WTF::makeUnique<WaitableEvent>();
     postTaskToWorkerGlobalScope(
         BLINK_FROM_HERE,
-        createCrossThreadTask(
-            &WorkerThreadableLoaderTestHelper::workerStartLoader,
-            crossThreadUnretained(this),
-            crossThreadUnretained(completionEvent.get()), request));
+        crossThreadBind(&WorkerThreadableLoaderTestHelper::workerStartLoader,
+                        crossThreadUnretained(this),
+                        crossThreadUnretained(completionEvent.get()), request));
     completionEvent->wait();
   }
 
   // Must be called on the worker thread.
   void cancelLoader() override {
     DCHECK(m_workerThread);
     DCHECK(m_workerThread->isCurrentThread());
     m_loader->cancel();
   }
 
@@ skipping 13 matching lines @@
 
   Checkpoint& checkpoint() override { return m_checkpoint; }
 
   void callCheckpoint(int n) override {
     testing::runPendingTasks();
 
     std::unique_ptr<WaitableEvent> completionEvent =
         WTF::makeUnique<WaitableEvent>();
     postTaskToWorkerGlobalScope(
         BLINK_FROM_HERE,
-        createCrossThreadTask(
-            &WorkerThreadableLoaderTestHelper::workerCallCheckpoint,
-            crossThreadUnretained(this),
-            crossThreadUnretained(completionEvent.get()), n));
+        crossThreadBind(&WorkerThreadableLoaderTestHelper::workerCallCheckpoint,
+                        crossThreadUnretained(this),
+                        crossThreadUnretained(completionEvent.get()), n));
     completionEvent->wait();
   }
 
   void onSetUp() override {
     m_mockWorkerReportingProxy = WTF::makeUnique<MockWorkerReportingProxy>();
     m_securityOrigin = document().getSecurityOrigin();
     m_parentFrameTaskRunners =
         ParentFrameTaskRunners::create(&m_dummyPageHolder->frame());
     m_workerThread = WTF::wrapUnique(
         new WorkerThreadForTest(this, *m_mockWorkerReportingProxy));
 
     expectWorkerLifetimeReportingCalls();
     m_workerThread->startWithSourceCode(m_securityOrigin.get(),
                                         "//fake source code");
     m_workerThread->waitForInit();
   }
 
   void onServeRequests() override { testing::runPendingTasks(); }
 
   void onTearDown() override {
     postTaskToWorkerGlobalScope(
         BLINK_FROM_HERE,
-        createCrossThreadTask(&WorkerThreadableLoaderTestHelper::clearLoader,
-                              crossThreadUnretained(this)));
+        crossThreadBind(&WorkerThreadableLoaderTestHelper::clearLoader,
+                        crossThreadUnretained(this)));
     WaitableEvent event;
     postTaskToWorkerGlobalScope(
-        BLINK_FROM_HERE, createCrossThreadTask(&WaitableEvent::signal,
-                                               crossThreadUnretained(&event)));
+        BLINK_FROM_HERE,
+        crossThreadBind(&WaitableEvent::signal, crossThreadUnretained(&event)));
     event.wait();
     m_workerThread->terminateAndWait();
 
     // Needed to clean up the things on the main thread side and
     // avoid Resource leaks.
     testing::runPendingTasks();
 
     m_workerThread->workerLoaderProxy()->detachProvider(this);
   }
 
@@ skipping 60 matching lines @@
     m_parentFrameTaskRunners->get(TaskType::Networking)
         ->postTask(
             BLINK_FROM_HERE,
             crossThreadBind(&ExecutionContextTask::performTaskIfContextIsValid,
                             WTF::passed(std::move(task)),
                             wrapCrossThreadWeakPersistent(&document())));
   }
 
   void postTaskToWorkerGlobalScope(
       const WebTraceLocation& location,
-      std::unique_ptr<ExecutionContextTask> task) override {
+      std::unique_ptr<WTF::CrossThreadClosure> task) override {
     DCHECK(m_workerThread);
     m_workerThread->postTask(location, std::move(task));
   }
 
   RefPtr<SecurityOrigin> m_securityOrigin;
   std::unique_ptr<MockWorkerReportingProxy> m_mockWorkerReportingProxy;
   std::unique_ptr<WorkerThreadForTest> m_workerThread;
 
   std::unique_ptr<DummyPageHolder> m_dummyPageHolder;
   Persistent<ParentFrameTaskRunners> m_parentFrameTaskRunners;
@@ skipping 529 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