(WIP) Worker: Merge ParentFrameTaskRunners into TaskRunnerHelper

third_party/WebKit/Source/core/html/canvas/CanvasAsyncBlobCreator.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/html/canvas/CanvasAsyncBlobCreator.h"
 
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/fileapi/Blob.h"
@@ skipping 185 matching lines @@
       m_mimeType(mimeType),
       m_startTime(startTime),
       m_elapsedTime(0),
       m_callback(callback),
       m_scriptPromiseResolver(resolver) {
   DCHECK(m_data->length() == (unsigned)(size.height() * size.width() * 4));
   m_encodedImage = WTF::wrapUnique(new Vector<unsigned char>());
   m_pixelRowStride = size.width() * NumChannelsPng;
   m_idleTaskStatus = IdleTaskNotSupported;
   m_numRowsCompleted = 0;
-  if (document) {
-    m_parentFrameTaskRunner = ParentFrameTaskRunners::create(document->frame());
-  }
   if (m_scriptPromiseResolver) {
     m_functionType = OffscreenCanvasToBlobPromise;
   } else {
     m_functionType = HTMLCanvasToBlobCallback;
   }
 }
 
 CanvasAsyncBlobCreator::~CanvasAsyncBlobCreator() {}
 
 void CanvasAsyncBlobCreator::dispose() {
   // Eagerly let go of references to prevent retention of these
   // resources while any remaining posted tasks are queued.
   m_data.clear();
   m_document.clear();
-  m_parentFrameTaskRunner.clear();
   m_callback.clear();
   m_scriptPromiseResolver.clear();
 }
 
 void CanvasAsyncBlobCreator::scheduleAsyncBlobCreation(const double& quality) {
   if (m_mimeType == MimeTypeWebp) {
     if (!isMainThread()) {
       DCHECK(m_functionType == OffscreenCanvasToBlobPromise);
       // When OffscreenCanvas.convertToBlob() occurs on worker thread,
       // we do not need to use background task runner to reduce load on main.
@@ skipping 251 matching lines @@
   // Avoid unwanted retention, see dispose().
   dispose();
 }
 
 void CanvasAsyncBlobCreator::encodeImageOnEncoderThread(double quality) {
   DCHECK(!isMainThread());
   DCHECK(m_mimeType == MimeTypeWebp);
 
   if (!ImageDataBuffer(m_size, m_data->data())
            .encodeImage("image/webp", quality, m_encodedImage.get())) {
-    m_parentFrameTaskRunner->get(TaskType::CanvasBlobSerialization)
+    FrameTaskRunnerHelper::get(TaskType::CanvasBlobSerialization,
+                               m_document.get())
         ->postTask(
             BLINK_FROM_HERE,
             crossThreadBind(&CanvasAsyncBlobCreator::createNullAndReturnResult,
                             wrapCrossThreadPersistent(this)));
     return;
   }
 
-  m_parentFrameTaskRunner->get(TaskType::CanvasBlobSerialization)
+  FrameTaskRunnerHelper::get(TaskType::CanvasBlobSerialization,
+                             m_document.get())
       ->postTask(
           BLINK_FROM_HERE,
           crossThreadBind(&CanvasAsyncBlobCreator::createBlobAndReturnResult,
                           wrapCrossThreadPersistent(this)));
 }
 
 bool CanvasAsyncBlobCreator::initializePngStruct() {
   m_pngEncoderState =
       PNGImageEncoderState::create(m_size, m_encodedImage.get());
   if (!m_pngEncoderState) {
@@ skipping 97 matching lines @@
     std::unique_ptr<WTF::Closure> task,
     double delayMs) {
   TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
       ->postDelayedTask(location, std::move(task), delayMs);
 }
 
 DEFINE_TRACE(CanvasAsyncBlobCreator) {
   visitor->trace(m_document);
   visitor->trace(m_data);
   visitor->trace(m_callback);
-  visitor->trace(m_parentFrameTaskRunner);
   visitor->trace(m_scriptPromiseResolver);
 }
 
 }  // namespace blink