Implement convertToBlob() in OffscreenCanvas

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/Document.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/fileapi/Blob.h"
 #include "platform/CrossThreadFunctional.h"
@@ skipping 68 matching lines @@
     mimeTypeEnum = CanvasAsyncBlobCreator::MimeTypeJpeg;
   } else if (mimeType == "image/webp") {
     mimeTypeEnum = CanvasAsyncBlobCreator::MimeTypeWebp;
   } else {
     mimeTypeEnum = CanvasAsyncBlobCreator::NumberOfMimeTypeSupported;
   }
   return mimeTypeEnum;
 }
 
 void recordIdleTaskStatusHistogram(
+    CanvasAsyncBlobCreator::ToBlobFunctionType functionType,
     CanvasAsyncBlobCreator::IdleTaskStatus status) {
+  // TODO(crbug.com/653599): Add histograms for OffscreenCanvas.convertToBlob.
+  if (functionType == CanvasAsyncBlobCreator::OffscreenCanvasToBlobPromise)
+    return;
   DEFINE_STATIC_LOCAL(EnumerationHistogram, toBlobIdleTaskStatus,
                       ("Blink.Canvas.ToBlob.IdleTaskStatus",
                        CanvasAsyncBlobCreator::IdleTaskCount));
   toBlobIdleTaskStatus.count(status);
 }
 
 // This enum is used in histogram and any more types should be appended at the
 // end of the list.
 enum ElapsedTimeHistogramType {
   InitiateEncodingDelay,
   IdleEncodeDuration,
   ToBlobDuration,
   NumberOfElapsedTimeHistogramTypes
 };
 
-void recordElapsedTimeHistogram(ElapsedTimeHistogramType type,
-                                CanvasAsyncBlobCreator::MimeType mimeType,
-                                double elapsedTime) {
+void recordElapsedTimeHistogram(
+    CanvasAsyncBlobCreator::ToBlobFunctionType functionType,
+    ElapsedTimeHistogramType type,
+    CanvasAsyncBlobCreator::MimeType mimeType,
+    double elapsedTime) {
+  // TODO(crbug.com/653599): Add histograms for OffscreenCanvas.convertToBlob.
+  if (functionType == CanvasAsyncBlobCreator::OffscreenCanvasToBlobPromise)
+    return;
+
   if (type == InitiateEncodingDelay) {
     if (mimeType == CanvasAsyncBlobCreator::MimeTypePng) {
       DEFINE_STATIC_LOCAL(
           CustomCountHistogram, toBlobPNGInitiateEncodingCounter,
           ("Blink.Canvas.ToBlob.InitiateEncodingDelay.PNG", 0, 10000000, 50));
       toBlobPNGInitiateEncodingCounter.count(elapsedTime * 1000000.0);
     } else if (mimeType == CanvasAsyncBlobCreator::MimeTypeJpeg) {
       DEFINE_STATIC_LOCAL(
           CustomCountHistogram, toBlobJPEGInitiateEncodingCounter,
           ("Blink.Canvas.ToBlob.InitiateEncodingDelay.JPEG", 0, 10000000, 50));
@@ skipping 31 matching lines @@
 }
 
 }  // anonymous namespace
 
 CanvasAsyncBlobCreator* CanvasAsyncBlobCreator::create(
     DOMUint8ClampedArray* unpremultipliedRGBAImageData,
     const String& mimeType,
     const IntSize& size,
     BlobCallback* callback,
     double startTime,
-    Document& document) {
+    Document* document) {
   return new CanvasAsyncBlobCreator(unpremultipliedRGBAImageData,
                                     convertMimeTypeStringToEnum(mimeType), size,
-                                    callback, startTime, document);
+                                    callback, startTime, document, nullptr);
+}
+
+CanvasAsyncBlobCreator* CanvasAsyncBlobCreator::create(
+    DOMUint8ClampedArray* unpremultipliedRGBAImageData,
+    const String& mimeType,
+    const IntSize& size,
+    double startTime,
+    Document* document,
+    ScriptPromiseResolver* resolver) {
+  return new CanvasAsyncBlobCreator(unpremultipliedRGBAImageData,
+                                    convertMimeTypeStringToEnum(mimeType), size,
+                                    nullptr, startTime, document, resolver);
 }
 
 CanvasAsyncBlobCreator::CanvasAsyncBlobCreator(DOMUint8ClampedArray* data,
                                                MimeType mimeType,
                                                const IntSize& size,
                                                BlobCallback* callback,
                                                double startTime,
-                                               Document& document)
+                                               Document* document,
+                                               ScriptPromiseResolver* resolver)
     : m_data(data),
-      m_document(&document),
+      m_document(document),
       m_size(size),
       m_mimeType(mimeType),
-      m_callback(callback),
       m_startTime(startTime),
       m_elapsedTime(0),
-      m_parentFrameTaskRunner(
-          ParentFrameTaskRunners::create(document.frame())) {
-  ASSERT(m_data->length() == (unsigned)(size.height() * size.width() * 4));
+      m_callback(callback),
+      m_scriptPromiseResolver(resolver) {
+  DCHECK(m_data->length() == (unsigned)(size.height() * size.width() * 4));
   m_encodedImage = 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(
-    bool canUseIdlePeriodScheduling,
-    const double& quality) {
-  ASSERT(isMainThread());
+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.
+      // So we just directly encode images on the worker thread.
+      if (!ImageDataBuffer(m_size, m_data->data())
+               .encodeImage("image/webp", quality, m_encodedImage.get())) {
+        TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
+            ->postTask(
+                BLINK_FROM_HERE,
+                WTF::bind(&CanvasAsyncBlobCreator::createNullAndReturnResult,
+                          wrapPersistent(this)));
 
-  if (canUseIdlePeriodScheduling) {
+        return;
+      }
+      TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
+          ->postTask(
+              BLINK_FROM_HERE,
+              WTF::bind(&CanvasAsyncBlobCreator::createBlobAndReturnResult,
+                        wrapPersistent(this)));
+
+    } else {
+      BackgroundTaskRunner::TaskSize taskSize =
+          (m_size.height() * m_size.width() >= LongTaskImageSizeThreshold)
+              ? BackgroundTaskRunner::TaskSizeLongRunningTask
+              : BackgroundTaskRunner::TaskSizeShortRunningTask;
+      BackgroundTaskRunner::postOnBackgroundThread(
+          BLINK_FROM_HERE,
+          crossThreadBind(&CanvasAsyncBlobCreator::encodeImageOnEncoderThread,
+                          wrapCrossThreadPersistent(this), quality),
+          taskSize);
+    }
+  } else {
     m_idleTaskStatus = IdleTaskNotStarted;
     if (m_mimeType == MimeTypePng) {
       this->scheduleInitiatePngEncoding();
     } else if (m_mimeType == MimeTypeJpeg) {
       this->scheduleInitiateJpegEncoding(quality);
     } else {
       // Progressive encoding is only applicable to png and jpeg image format,
       // and thus idle tasks scheduling can only be applied to these image
       // formats.
       // TODO(xlai): Progressive encoding on webp image formats
       // (crbug.com/571399)
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
     }
-    // We post the below task to check if the above idle task isn't late.
-    // There's no risk of concurrency as both tasks are on main thread.
-    this->postDelayedTaskToMainThread(
-        BLINK_FROM_HERE,
-        WTF::bind(&CanvasAsyncBlobCreator::idleTaskStartTimeoutEvent,
-                  wrapPersistent(this), quality),
-        IdleTaskStartTimeoutDelay);
-  } else if (m_mimeType == MimeTypeWebp) {
-    BackgroundTaskRunner::TaskSize taskSize =
-        (m_size.height() * m_size.width() >= LongTaskImageSizeThreshold)
-            ? BackgroundTaskRunner::TaskSizeLongRunningTask
-            : BackgroundTaskRunner::TaskSizeShortRunningTask;
-    BackgroundTaskRunner::postOnBackgroundThread(
-        BLINK_FROM_HERE,
-        crossThreadBind(&CanvasAsyncBlobCreator::encodeImageOnEncoderThread,
-                        wrapCrossThreadPersistent(this), quality),
-        taskSize);
+
+    // TODO: Enforce OffscreenCanvas.convertToBlob to finish within deadline.
+    // See crbug.com/657102.
+    if (m_functionType == HTMLCanvasToBlobCallback) {
+      // We post the below task to check if the above idle task isn't late.
+      // There's no risk of concurrency as both tasks are on main thread.
+      this->postDelayedTaskToMainThread(
+          BLINK_FROM_HERE,
+          WTF::bind(&CanvasAsyncBlobCreator::idleTaskStartTimeoutEvent,
+                    wrapPersistent(this), quality),
+          IdleTaskStartTimeoutDelay);
+    }
   }
 }
 
 void CanvasAsyncBlobCreator::scheduleInitiateJpegEncoding(
     const double& quality) {
   m_scheduleInitiateStartTime = WTF::monotonicallyIncreasingTime();
-  Platform::current()->mainThread()->scheduler()->postIdleTask(
+  Platform::current()->currentThread()->scheduler()->postIdleTask(
       BLINK_FROM_HERE, WTF::bind(&CanvasAsyncBlobCreator::initiateJpegEncoding,
                                  wrapPersistent(this), quality));
 }
 
 void CanvasAsyncBlobCreator::initiateJpegEncoding(const double& quality,
                                                   double deadlineSeconds) {
-  ASSERT(isMainThread());
   recordElapsedTimeHistogram(
-      InitiateEncodingDelay, MimeTypeJpeg,
+      m_functionType, InitiateEncodingDelay, MimeTypeJpeg,
       WTF::monotonicallyIncreasingTime() - m_scheduleInitiateStartTime);
-  if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) {
+  if (m_idleTaskStatus == IdleTaskSwitchedToImmediateTask) {
     return;
   }
 
-  ASSERT(m_idleTaskStatus == IdleTaskNotStarted);
+  DCHECK(m_idleTaskStatus == IdleTaskNotStarted);
   m_idleTaskStatus = IdleTaskStarted;
 
   if (!initializeJpegStruct(quality)) {
     m_idleTaskStatus = IdleTaskFailed;
     return;
   }
   this->idleEncodeRowsJpeg(deadlineSeconds);
 }
 
 void CanvasAsyncBlobCreator::scheduleInitiatePngEncoding() {
   m_scheduleInitiateStartTime = WTF::monotonicallyIncreasingTime();
-  Platform::current()->mainThread()->scheduler()->postIdleTask(
+  Platform::current()->currentThread()->scheduler()->postIdleTask(
       BLINK_FROM_HERE, WTF::bind(&CanvasAsyncBlobCreator::initiatePngEncoding,
                                  wrapPersistent(this)));
 }
 
 void CanvasAsyncBlobCreator::initiatePngEncoding(double deadlineSeconds) {
-  ASSERT(isMainThread());
   recordElapsedTimeHistogram(
-      InitiateEncodingDelay, MimeTypePng,
+      m_functionType, InitiateEncodingDelay, MimeTypePng,
       WTF::monotonicallyIncreasingTime() - m_scheduleInitiateStartTime);
-
-  if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) {
+  if (m_idleTaskStatus == IdleTaskSwitchedToImmediateTask) {
     return;
   }
 
-  ASSERT(m_idleTaskStatus == IdleTaskNotStarted);
+  DCHECK(m_idleTaskStatus == IdleTaskNotStarted);
   m_idleTaskStatus = IdleTaskStarted;
 
   if (!initializePngStruct()) {
     m_idleTaskStatus = IdleTaskFailed;
     return;
   }
   this->idleEncodeRowsPng(deadlineSeconds);
 }
 
 void CanvasAsyncBlobCreator::idleEncodeRowsPng(double deadlineSeconds) {
-  ASSERT(isMainThread());
-  if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) {
+  if (m_idleTaskStatus == IdleTaskSwitchedToImmediateTask) {
     return;
   }
 
   double startTime = WTF::monotonicallyIncreasingTime();
   unsigned char* inputPixels =
       m_data->data() + m_pixelRowStride * m_numRowsCompleted;
   for (int y = m_numRowsCompleted; y < m_size.height(); ++y) {
     if (isDeadlineNearOrPassed(deadlineSeconds)) {
       m_numRowsCompleted = y;
       m_elapsedTime += (WTF::monotonicallyIncreasingTime() - startTime);
       Platform::current()->currentThread()->scheduler()->postIdleTask(
           BLINK_FROM_HERE, WTF::bind(&CanvasAsyncBlobCreator::idleEncodeRowsPng,
                                      wrapPersistent(this)));
       return;
     }
     PNGImageEncoder::writeOneRowToPng(inputPixels, m_pngEncoderState.get());
     inputPixels += m_pixelRowStride;
   }
   m_numRowsCompleted = m_size.height();
   PNGImageEncoder::finalizePng(m_pngEncoderState.get());
 
   m_idleTaskStatus = IdleTaskCompleted;
   m_elapsedTime += (WTF::monotonicallyIncreasingTime() - startTime);
-  recordElapsedTimeHistogram(IdleEncodeDuration, MimeTypePng, m_elapsedTime);
+  recordElapsedTimeHistogram(m_functionType, IdleEncodeDuration, MimeTypePng,
+                             m_elapsedTime);
   if (isDeadlineNearOrPassed(deadlineSeconds)) {
     TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
-        ->postTask(
-            BLINK_FROM_HERE,
-            WTF::bind(&CanvasAsyncBlobCreator::createBlobAndInvokeCallback,
-                      wrapPersistent(this)));
+        ->postTask(BLINK_FROM_HERE,
+                   WTF::bind(&CanvasAsyncBlobCreator::createBlobAndReturnResult,
+                             wrapPersistent(this)));
   } else {
-    this->createBlobAndInvokeCallback();
+    this->createBlobAndReturnResult();
   }
 }
 
 void CanvasAsyncBlobCreator::idleEncodeRowsJpeg(double deadlineSeconds) {
-  ASSERT(isMainThread());
-  if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) {
+  if (m_idleTaskStatus == IdleTaskSwitchedToImmediateTask) {
     return;
   }
 
   double startTime = WTF::monotonicallyIncreasingTime();
   m_numRowsCompleted = JPEGImageEncoder::progressiveEncodeRowsJpegHelper(
       m_jpegEncoderState.get(), m_data->data(), m_numRowsCompleted,
       SlackBeforeDeadline, deadlineSeconds);
   m_elapsedTime += (WTF::monotonicallyIncreasingTime() - startTime);
   if (m_numRowsCompleted == m_size.height()) {
     m_idleTaskStatus = IdleTaskCompleted;
-    recordElapsedTimeHistogram(IdleEncodeDuration, MimeTypeJpeg, m_elapsedTime);
+    recordElapsedTimeHistogram(m_functionType, IdleEncodeDuration, MimeTypeJpeg,
+                               m_elapsedTime);
 
     if (isDeadlineNearOrPassed(deadlineSeconds)) {
       TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
           ->postTask(
               BLINK_FROM_HERE,
-              WTF::bind(&CanvasAsyncBlobCreator::createBlobAndInvokeCallback,
+              WTF::bind(&CanvasAsyncBlobCreator::createBlobAndReturnResult,
                         wrapPersistent(this)));
     } else {
-      this->createBlobAndInvokeCallback();
+      this->createBlobAndReturnResult();
     }
   } else if (m_numRowsCompleted == JPEGImageEncoder::ProgressiveEncodeFailed) {
     m_idleTaskStatus = IdleTaskFailed;
-    this->createNullAndInvokeCallback();
+    this->createNullAndReturnResult();
   } else {
     Platform::current()->currentThread()->scheduler()->postIdleTask(
         BLINK_FROM_HERE, WTF::bind(&CanvasAsyncBlobCreator::idleEncodeRowsJpeg,
                                    wrapPersistent(this)));
   }
 }
 
 void CanvasAsyncBlobCreator::encodeRowsPngOnMainThread() {
-  ASSERT(m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask);
+  DCHECK(m_idleTaskStatus == IdleTaskSwitchedToImmediateTask);
 
   // Continue encoding from the last completed row
   unsigned char* inputPixels =
       m_data->data() + m_pixelRowStride * m_numRowsCompleted;
   for (int y = m_numRowsCompleted; y < m_size.height(); ++y) {
     PNGImageEncoder::writeOneRowToPng(inputPixels, m_pngEncoderState.get());
     inputPixels += m_pixelRowStride;
   }
   PNGImageEncoder::finalizePng(m_pngEncoderState.get());
-  this->createBlobAndInvokeCallback();
+  this->createBlobAndReturnResult();
 
   this->signalAlternativeCodePathFinishedForTesting();
 }
 
 void CanvasAsyncBlobCreator::encodeRowsJpegOnMainThread() {
-  ASSERT(m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask);
+  DCHECK(m_idleTaskStatus == IdleTaskSwitchedToImmediateTask);
 
   // Continue encoding from the last completed row
   if (JPEGImageEncoder::encodeWithPreInitializedState(
           std::move(m_jpegEncoderState), m_data->data(), m_numRowsCompleted)) {
-    this->createBlobAndInvokeCallback();
+    this->createBlobAndReturnResult();
   } else {
-    this->createNullAndInvokeCallback();
+    this->createNullAndReturnResult();
   }
 
   this->signalAlternativeCodePathFinishedForTesting();
 }
 
-void CanvasAsyncBlobCreator::createBlobAndInvokeCallback() {
-  ASSERT(isMainThread());
-  recordIdleTaskStatusHistogram(m_idleTaskStatus);
+void CanvasAsyncBlobCreator::createBlobAndReturnResult() {
+  recordIdleTaskStatusHistogram(m_functionType, m_idleTaskStatus);
+  recordElapsedTimeHistogram(m_functionType, ToBlobDuration, m_mimeType,
+                             WTF::monotonicallyIncreasingTime() - m_startTime);
 
-  recordElapsedTimeHistogram(ToBlobDuration, m_mimeType,
-                             WTF::monotonicallyIncreasingTime() - m_startTime);
   Blob* resultBlob =
       Blob::create(m_encodedImage->data(), m_encodedImage->size(),
                    convertMimeTypeEnumToString(m_mimeType));
-  TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
-      ->postTask(BLINK_FROM_HERE, WTF::bind(&BlobCallback::handleEvent,
-                                            wrapPersistent(m_callback.get()),
-                                            wrapPersistent(resultBlob)));
+  if (m_functionType == HTMLCanvasToBlobCallback) {
+    TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
+        ->postTask(BLINK_FROM_HERE, WTF::bind(&BlobCallback::handleEvent,
+                                              wrapPersistent(m_callback.get()),
+                                              wrapPersistent(resultBlob)));
+  } else {
+    m_scriptPromiseResolver->resolve(resultBlob);
+  }
   // Avoid unwanted retention, see dispose().
   dispose();
 }
 
-void CanvasAsyncBlobCreator::createNullAndInvokeCallback() {
-  ASSERT(isMainThread());
-  recordIdleTaskStatusHistogram(m_idleTaskStatus);
-  TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
-      ->postTask(BLINK_FROM_HERE,
-                 WTF::bind(&BlobCallback::handleEvent,
-                           wrapPersistent(m_callback.get()), nullptr));
+void CanvasAsyncBlobCreator::createNullAndReturnResult() {
+  recordIdleTaskStatusHistogram(m_functionType, m_idleTaskStatus);
+  if (m_functionType == HTMLCanvasToBlobCallback) {
+    DCHECK(isMainThread());
+    recordIdleTaskStatusHistogram(m_functionType, m_idleTaskStatus);
+    TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
+        ->postTask(BLINK_FROM_HERE,
+                   WTF::bind(&BlobCallback::handleEvent,
+                             wrapPersistent(m_callback.get()), nullptr));
+  } else {
+    Blob* blob = nullptr;
+    m_scriptPromiseResolver->reject(blob);
+  }
   // Avoid unwanted retention, see dispose().
   dispose();
 }
 
 void CanvasAsyncBlobCreator::encodeImageOnEncoderThread(double quality) {
-  ASSERT(!isMainThread());
-  ASSERT(m_mimeType == MimeTypeWebp);
+  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)
         ->postTask(BLINK_FROM_HERE,
                    crossThreadBind(&BlobCallback::handleEvent,
                                    wrapCrossThreadPersistent(m_callback.get()),
                                    nullptr));
     return;
   }
 
   m_parentFrameTaskRunner->get(TaskType::CanvasBlobSerialization)
       ->postTask(
           BLINK_FROM_HERE,
-          crossThreadBind(&CanvasAsyncBlobCreator::createBlobAndInvokeCallback,
+          crossThreadBind(&CanvasAsyncBlobCreator::createBlobAndReturnResult,
                           wrapCrossThreadPersistent(this)));
 }
 
 bool CanvasAsyncBlobCreator::initializePngStruct() {
   m_pngEncoderState =
       PNGImageEncoderState::create(m_size, m_encodedImage.get());
   if (!m_pngEncoderState) {
-    this->createNullAndInvokeCallback();
+    this->createNullAndReturnResult();
     return false;
   }
   return true;
 }
 
 bool CanvasAsyncBlobCreator::initializeJpegStruct(double quality) {
   m_jpegEncoderState =
       JPEGImageEncoderState::create(m_size, quality, m_encodedImage.get());
   if (!m_jpegEncoderState) {
-    this->createNullAndInvokeCallback();
+    this->createNullAndReturnResult();
     return false;
   }
   return true;
 }
 
 void CanvasAsyncBlobCreator::idleTaskStartTimeoutEvent(double quality) {
   if (m_idleTaskStatus == IdleTaskStarted) {
     // Even if the task started quickly, we still want to ensure completion
     this->postDelayedTaskToMainThread(
         BLINK_FROM_HERE,
         WTF::bind(&CanvasAsyncBlobCreator::idleTaskCompleteTimeoutEvent,
                   wrapPersistent(this)),
         IdleTaskCompleteTimeoutDelay);
   } else if (m_idleTaskStatus == IdleTaskNotStarted) {
     // If the idle task does not start after a delay threshold, we will
     // force it to happen on main thread (even though it may cause more
     // janks) to prevent toBlob being postponed forever in extreme cases.
-    m_idleTaskStatus = IdleTaskSwitchedToMainThreadTask;
+    m_idleTaskStatus = IdleTaskSwitchedToImmediateTask;
     signalTaskSwitchInStartTimeoutEventForTesting();
 
     if (m_mimeType == MimeTypePng) {
       if (initializePngStruct()) {
         TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
             ->postTask(
                 BLINK_FROM_HERE,
                 WTF::bind(&CanvasAsyncBlobCreator::encodeRowsPngOnMainThread,
                           wrapPersistent(this)));
       } else {
         // Failing in initialization of png struct
         this->signalAlternativeCodePathFinishedForTesting();
       }
     } else {
-      ASSERT(m_mimeType == MimeTypeJpeg);
+      DCHECK(m_mimeType == MimeTypeJpeg);
       if (initializeJpegStruct(quality)) {
         TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
             ->postTask(
                 BLINK_FROM_HERE,
                 WTF::bind(&CanvasAsyncBlobCreator::encodeRowsJpegOnMainThread,
                           wrapPersistent(this)));
       } else {
         // Failing in initialization of jpeg struct
         this->signalAlternativeCodePathFinishedForTesting();
       }
     }
   } else {
-    ASSERT(m_idleTaskStatus == IdleTaskFailed ||
+    DCHECK(m_idleTaskStatus == IdleTaskFailed ||
            m_idleTaskStatus == IdleTaskCompleted);
     this->signalAlternativeCodePathFinishedForTesting();
   }
 }
 
 void CanvasAsyncBlobCreator::idleTaskCompleteTimeoutEvent() {
-  ASSERT(m_idleTaskStatus != IdleTaskNotStarted);
+  DCHECK(m_idleTaskStatus != IdleTaskNotStarted);
 
   if (m_idleTaskStatus == IdleTaskStarted) {
     // It has taken too long to complete for the idle task.
-    m_idleTaskStatus = IdleTaskSwitchedToMainThreadTask;
+    m_idleTaskStatus = IdleTaskSwitchedToImmediateTask;
     signalTaskSwitchInCompleteTimeoutEventForTesting();
 
     if (m_mimeType == MimeTypePng) {
       TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
           ->postTask(
               BLINK_FROM_HERE,
               WTF::bind(&CanvasAsyncBlobCreator::encodeRowsPngOnMainThread,
                         wrapPersistent(this)));
     } else {
-      ASSERT(m_mimeType == MimeTypeJpeg);
+      DCHECK(m_mimeType == MimeTypeJpeg);
       TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
           ->postTask(
               BLINK_FROM_HERE,
               WTF::bind(&CanvasAsyncBlobCreator::encodeRowsJpegOnMainThread,
                         wrapPersistent(this)));
     }
   } else {
-    ASSERT(m_idleTaskStatus == IdleTaskFailed ||
+    DCHECK(m_idleTaskStatus == IdleTaskFailed ||
            m_idleTaskStatus == IdleTaskCompleted);
     this->signalAlternativeCodePathFinishedForTesting();
   }
 }
 
 void CanvasAsyncBlobCreator::postDelayedTaskToMainThread(
     const WebTraceLocation& location,
     std::unique_ptr<WTF::Closure> task,
     double delayMs) {
   DCHECK(isMainThread());
   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