Worker: Stop using ExecutionContextTask on WorkerLoaderProxy::postTaskToWorkerGlobalScope

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 26 matching lines @@
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/network/ResourceTimingInfo.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityPolicy.h"
+#include "wtf/Functional.h"
 #include "wtf/debug/Alias.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
 std::unique_ptr<Vector<char>> createVectorFromMemoryRegion(
     const char* data,
     unsigned dataLength) {
   std::unique_ptr<Vector<char>> buffer =
       WTF::makeUnique<Vector<char>>(dataLength);
   memcpy(buffer->data(), data, dataLength);
   return buffer;
 }
 
 }  // namespace
 
 class WorkerThreadableLoader::AsyncTaskForwarder final
     : public WorkerThreadableLoader::TaskForwarder {
  public:
   explicit AsyncTaskForwarder(PassRefPtr<WorkerLoaderProxy> loaderProxy)
       : m_loaderProxy(loaderProxy) {
     DCHECK(isMainThread());
   }
   ~AsyncTaskForwarder() override { DCHECK(isMainThread()); }
 
   void forwardTask(const WebTraceLocation& location,
-                   std::unique_ptr<ExecutionContextTask> task) override {
+                   std::unique_ptr<CrossThreadClosure> task) override {
     DCHECK(isMainThread());
     m_loaderProxy->postTaskToWorkerGlobalScope(location, std::move(task));
   }
   void forwardTaskWithDoneSignal(
       const WebTraceLocation& location,
-      std::unique_ptr<ExecutionContextTask> task) override {
+      std::unique_ptr<CrossThreadClosure> task) override {
     DCHECK(isMainThread());
     m_loaderProxy->postTaskToWorkerGlobalScope(location, std::move(task));
   }
   void abort() override { DCHECK(isMainThread()); }
 
  private:
   RefPtr<WorkerLoaderProxy> m_loaderProxy;
 };
 
 struct WorkerThreadableLoader::TaskWithLocation final {
   TaskWithLocation(const WebTraceLocation& location,
-                   std::unique_ptr<ExecutionContextTask> task)
+                   std::unique_ptr<CrossThreadClosure> task)
       : m_location(location), m_task(std::move(task)) {}
   TaskWithLocation(TaskWithLocation&& task)
       : TaskWithLocation(task.m_location, std::move(task.m_task)) {}
   ~TaskWithLocation() = default;
 
   WebTraceLocation m_location;
-  std::unique_ptr<ExecutionContextTask> m_task;
+  std::unique_ptr<CrossThreadClosure> m_task;
 };
 
 // Observing functions and wait() need to be called on the worker thread.
 // Setting functions and signal() need to be called on the main thread.
 // All observing functions must be called after wait() returns, and all
 // setting functions must be called before signal() is called.
 class WorkerThreadableLoader::WaitableEventWithTasks final
     : public ThreadSafeRefCounted<WaitableEventWithTasks> {
  public:
   static PassRefPtr<WaitableEventWithTasks> create() {
@@ skipping 50 matching lines @@
 class WorkerThreadableLoader::SyncTaskForwarder final
     : public WorkerThreadableLoader::TaskForwarder {
  public:
   explicit SyncTaskForwarder(PassRefPtr<WaitableEventWithTasks> eventWithTasks)
       : m_eventWithTasks(eventWithTasks) {
     DCHECK(isMainThread());
   }
   ~SyncTaskForwarder() override { DCHECK(isMainThread()); }
 
   void forwardTask(const WebTraceLocation& location,
-                   std::unique_ptr<ExecutionContextTask> task) override {
+                   std::unique_ptr<CrossThreadClosure> task) override {
     DCHECK(isMainThread());
     m_eventWithTasks->append(TaskWithLocation(location, std::move(task)));
   }
   void forwardTaskWithDoneSignal(
       const WebTraceLocation& location,
-      std::unique_ptr<ExecutionContextTask> task) override {
+      std::unique_ptr<CrossThreadClosure> task) override {
     DCHECK(isMainThread());
     m_eventWithTasks->append(TaskWithLocation(location, std::move(task)));
     m_eventWithTasks->signal();
   }
   void abort() override {
     DCHECK(isMainThread());
     m_eventWithTasks->setIsAborted();
     m_eventWithTasks->signal();
   }
 
@@ skipping 65 matching lines @@
     cancel();
     return;
   }
 
   for (const auto& task : eventWithTasks->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* programCounter = task.m_location.program_counter();
     WTF::debug::alias(&programCounter);
 
-    // m_clientTask contains only CallClosureTasks. So, it's ok to pass
-    // the nullptr.
-    task.m_task->performTask(nullptr);
+    (*task.m_task)();
   }
 }
 
 void WorkerThreadableLoader::overrideTimeout(
     unsigned long timeoutMilliseconds) {
   DCHECK(!isMainThread());
   if (!m_mainThreadLoaderHolder)
     return;
   m_workerLoaderProxy->postTaskToLoader(
       BLINK_FROM_HERE,
@@ skipping 171 matching lines @@
       new MainThreadLoaderHolder(forwarder, workerThreadLifecycleContext);
   if (mainThreadLoaderHolder->wasContextDestroyedBeforeObserverCreation()) {
     // The thread is already terminating.
     forwarder->abort();
     mainThreadLoaderHolder->m_forwarder = nullptr;
     return;
   }
   mainThreadLoaderHolder->m_workerLoader = workerLoader;
   forwarder->forwardTask(
       BLINK_FROM_HERE,
-      createCrossThreadTask(&WorkerThreadableLoader::didStart,
-                            wrapCrossThreadPersistent(workerLoader),
-                            wrapCrossThreadPersistent(mainThreadLoaderHolder)));
+      crossThreadBind(&WorkerThreadableLoader::didStart,
+                      wrapCrossThreadPersistent(workerLoader),
+                      wrapCrossThreadPersistent(mainThreadLoaderHolder)));
   mainThreadLoaderHolder->start(*toDocument(executionContext),
                                 std::move(request), options,
                                 resourceLoaderOptions);
 }
 
 WorkerThreadableLoader::MainThreadLoaderHolder::~MainThreadLoaderHolder() {
   DCHECK(isMainThread());
   DCHECK(!m_workerLoader);
 }
 
@@ skipping 17 matching lines @@
 void WorkerThreadableLoader::MainThreadLoaderHolder::didSendData(
     unsigned long long bytesSent,
     unsigned long long totalBytesToBeSent) {
   DCHECK(isMainThread());
   CrossThreadPersistent<WorkerThreadableLoader> workerLoader =
       m_workerLoader.get();
   if (!workerLoader || !m_forwarder)
     return;
   m_forwarder->forwardTask(
       BLINK_FROM_HERE,
-      createCrossThreadTask(&WorkerThreadableLoader::didSendData, workerLoader,
-                            bytesSent, totalBytesToBeSent));
+      crossThreadBind(&WorkerThreadableLoader::didSendData, workerLoader,
+                      bytesSent, totalBytesToBeSent));
 }
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveRedirectTo(
     const KURL& url) {
   DCHECK(isMainThread());
   CrossThreadPersistent<WorkerThreadableLoader> workerLoader =
       m_workerLoader.get();
   if (!workerLoader || !m_forwarder)
     return;
   m_forwarder->forwardTask(
       BLINK_FROM_HERE,
-      createCrossThreadTask(&WorkerThreadableLoader::didReceiveRedirectTo,
-                            workerLoader, url));
+      crossThreadBind(&WorkerThreadableLoader::didReceiveRedirectTo,
+                      workerLoader, url));
 }
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveResponse(
     unsigned long identifier,
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   DCHECK(isMainThread());
   CrossThreadPersistent<WorkerThreadableLoader> workerLoader =
       m_workerLoader.get();
   if (!workerLoader || !m_forwarder)
     return;
   m_forwarder->forwardTask(
       BLINK_FROM_HERE,
-      createCrossThreadTask(&WorkerThreadableLoader::didReceiveResponse,
-                            workerLoader, identifier, response,
-                            WTF::passed(std::move(handle))));
+      crossThreadBind(&WorkerThreadableLoader::didReceiveResponse, workerLoader,
+                      identifier, response, WTF::passed(std::move(handle))));
 }
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveData(
     const char* data,
     unsigned dataLength) {
   DCHECK(isMainThread());
   CrossThreadPersistent<WorkerThreadableLoader> workerLoader =
       m_workerLoader.get();
   if (!workerLoader || !m_forwarder)
     return;
   m_forwarder->forwardTask(
       BLINK_FROM_HERE,
-      createCrossThreadTask(
+      crossThreadBind(
           &WorkerThreadableLoader::didReceiveData, workerLoader,
           WTF::passed(createVectorFromMemoryRegion(data, dataLength))));
 }
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::didDownloadData(
     int dataLength) {
   DCHECK(isMainThread());
   CrossThreadPersistent<WorkerThreadableLoader> workerLoader =
       m_workerLoader.get();
   if (!workerLoader || !m_forwarder)
     return;
   m_forwarder->forwardTask(
-      BLINK_FROM_HERE,
-      createCrossThreadTask(&WorkerThreadableLoader::didDownloadData,
-                            workerLoader, dataLength));
+      BLINK_FROM_HERE, crossThreadBind(&WorkerThreadableLoader::didDownloadData,
+                                       workerLoader, dataLength));
 }
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveCachedMetadata(
     const char* data,
     int dataLength) {
   DCHECK(isMainThread());
   CrossThreadPersistent<WorkerThreadableLoader> workerLoader =
       m_workerLoader.get();
   if (!workerLoader || !m_forwarder)
     return;
   m_forwarder->forwardTask(
       BLINK_FROM_HERE,
-      createCrossThreadTask(
+      crossThreadBind(
           &WorkerThreadableLoader::didReceiveCachedMetadata, workerLoader,
           WTF::passed(createVectorFromMemoryRegion(data, dataLength))));
 }
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::didFinishLoading(
     unsigned long identifier,
     double finishTime) {
   DCHECK(isMainThread());
   CrossThreadPersistent<WorkerThreadableLoader> workerLoader =
       m_workerLoader.release();
   if (!workerLoader || !m_forwarder)
     return;
   m_forwarder->forwardTaskWithDoneSignal(
       BLINK_FROM_HERE,
-      createCrossThreadTask(&WorkerThreadableLoader::didFinishLoading,
-                            workerLoader, identifier, finishTime));
+      crossThreadBind(&WorkerThreadableLoader::didFinishLoading, workerLoader,
+                      identifier, finishTime));
   m_forwarder = nullptr;
 }
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::didFail(
     const ResourceError& error) {
   DCHECK(isMainThread());
   CrossThreadPersistent<WorkerThreadableLoader> workerLoader =
       m_workerLoader.release();
   if (!workerLoader || !m_forwarder)
     return;
   m_forwarder->forwardTaskWithDoneSignal(
-      BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didFail,
-                                             workerLoader, error));
+      BLINK_FROM_HERE,
+      crossThreadBind(&WorkerThreadableLoader::didFail, workerLoader, error));
   m_forwarder = nullptr;
 }
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::didFailAccessControlCheck(
     const ResourceError& error) {
   DCHECK(isMainThread());
   CrossThreadPersistent<WorkerThreadableLoader> workerLoader =
       m_workerLoader.release();
   if (!workerLoader || !m_forwarder)
     return;
   m_forwarder->forwardTaskWithDoneSignal(
       BLINK_FROM_HERE,
-      createCrossThreadTask(&WorkerThreadableLoader::didFailAccessControlCheck,
-                            workerLoader, error));
+      crossThreadBind(&WorkerThreadableLoader::didFailAccessControlCheck,
+                      workerLoader, error));
   m_forwarder = nullptr;
 }
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::didFailRedirectCheck() {
   DCHECK(isMainThread());
   CrossThreadPersistent<WorkerThreadableLoader> workerLoader =
       m_workerLoader.release();
   if (!workerLoader || !m_forwarder)
     return;
   m_forwarder->forwardTaskWithDoneSignal(
       BLINK_FROM_HERE,
-      createCrossThreadTask(&WorkerThreadableLoader::didFailRedirectCheck,
-                            workerLoader));
+      crossThreadBind(&WorkerThreadableLoader::didFailRedirectCheck,
+                      workerLoader));
   m_forwarder = nullptr;
 }
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveResourceTiming(
     const ResourceTimingInfo& info) {
   DCHECK(isMainThread());
   CrossThreadPersistent<WorkerThreadableLoader> workerLoader =
       m_workerLoader.get();
   if (!workerLoader || !m_forwarder)
     return;
   m_forwarder->forwardTask(
       BLINK_FROM_HERE,
-      createCrossThreadTask(&WorkerThreadableLoader::didReceiveResourceTiming,
-                            workerLoader, info));
+      crossThreadBind(&WorkerThreadableLoader::didReceiveResourceTiming,
+                      workerLoader, info));
 }
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::contextDestroyed(
     WorkerThreadLifecycleContext*) {
   DCHECK(isMainThread());
   if (m_forwarder) {
     m_forwarder->abort();
     m_forwarder = nullptr;
   }
   cancel();
@@ skipping 22 matching lines @@
   resourceLoaderOptions.requestInitiatorContext = WorkerContext;
   // TODO(yhirano): Remove this CHECK once https://crbug.com/667254 is fixed.
   CHECK(!m_mainThreadLoader);
   m_mainThreadLoader = DocumentThreadableLoader::create(
       document, this, options, resourceLoaderOptions,
       ThreadableLoader::ClientSpec::kMainThreadLoaderHolder);
   m_mainThreadLoader->start(ResourceRequest(request.get()));
 }
 
 }  // namespace blink