Use SkJpegEncoder in WebKit platform

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"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/Histogram.h"
 #include "platform/WebTaskRunner.h"
 #include "platform/graphics/ImageBuffer.h"
-#include "platform/image-encoders/JPEGImageEncoder.h"
-#include "platform/image-encoders/PNGImageEncoder.h"
 #include "platform/scheduler/child/web_scheduler.h"
 #include "platform/threading/BackgroundTaskRunner.h"
 #include "platform/wtf/CurrentTime.h"
 #include "platform/wtf/Functional.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 
 namespace blink {
 
 namespace {
 
 const double kSlackBeforeDeadline =
     0.001;  // a small slack period between deadline and current time for safety
-const int kNumChannelsPng = 4;
 
 // The encoding task is highly likely to switch from idle task to alternative
 // code path when the startTimeoutDelay is set to be below 150ms. As we want the
 // majority of encoding tasks to take the usual async idle task, we set a
 // lenient limit -- 200ms here. This limit still needs to be short enough for
 // the latency to be negligible to the user.
 const double kIdleTaskStartTimeoutDelay = 200.0;
 // We should be more lenient on completion timeout delay to ensure that the
 // switch from idle to main thread only happens to a minority of toBlob calls
 #if !OS(ANDROID)
@@ skipping 141 matching lines @@
 
 CanvasAsyncBlobCreator::CanvasAsyncBlobCreator(DOMUint8ClampedArray* data,
                                                MimeType mime_type,
                                                const IntSize& size,
                                                BlobCallback* callback,
                                                double start_time,
                                                Document* document,
                                                ScriptPromiseResolver* resolver)
     : data_(data),
       document_(document),
-      size_(size),
       mime_type_(mime_type),
       start_time_(start_time),
       elapsed_time_(0),
       callback_(callback),
       script_promise_resolver_(resolver) {
-  DCHECK(data_->length() == (unsigned)(size.Height() * size.Width() * 4));
-  encoded_image_ = WTF::WrapUnique(new Vector<unsigned char>());
-  pixel_row_stride_ = size.Width() * kNumChannelsPng;
+  size_t rowBytes = size.Width() * 4;
+  DCHECK(data_->length() == (unsigned)(size.Height() * rowBytes));
+  SkImageInfo info =
+      SkImageInfo::Make(size.Width(), size.Height(), kRGBA_8888_SkColorType,
+                        kUnpremul_SkAlphaType, nullptr);
+  src_data_.reset(info, data_->Data(), rowBytes);
   idle_task_status_ = kIdleTaskNotSupported;
   num_rows_completed_ = 0;
   if (document) {
     parent_frame_task_runner_ =
         ParentFrameTaskRunners::Create(document->GetFrame());
   }
   if (script_promise_resolver_) {
     function_type_ = kOffscreenCanvasToBlobPromise;
   } else {
     function_type_ = kHTMLCanvasToBlobCallback;
@@ skipping 12 matching lines @@
   script_promise_resolver_.Clear();
 }
 
 void CanvasAsyncBlobCreator::ScheduleAsyncBlobCreation(const double& quality) {
   if (mime_type_ == kMimeTypeWebp) {
     if (!IsMainThread()) {
       DCHECK(function_type_ == kOffscreenCanvasToBlobPromise);
       // 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(size_, data_->Data())
-               .EncodeImage("image/webp", quality, encoded_image_.get())) {
+      IntSize size(src_data_.width(), src_data_.height());
+      if (!ImageDataBuffer(size, data_->Data())
+               .EncodeImage("image/webp", quality, &encoded_image_)) {
         TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
             ->PostTask(
                 BLINK_FROM_HERE,
                 WTF::Bind(&CanvasAsyncBlobCreator::CreateNullAndReturnResult,
                           WrapPersistent(this)));
 
         return;
       }
       TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
           ->PostTask(
               BLINK_FROM_HERE,
               WTF::Bind(&CanvasAsyncBlobCreator::CreateBlobAndReturnResult,
                         WrapPersistent(this)));
 
     } else {
       BackgroundTaskRunner::PostOnBackgroundThread(
           BLINK_FROM_HERE,
           CrossThreadBind(&CanvasAsyncBlobCreator::EncodeImageOnEncoderThread,
                           WrapCrossThreadPersistent(this), quality));
     }
   } else {
     idle_task_status_ = kIdleTaskNotStarted;
-    if (mime_type_ == kMimeTypePng) {
-      this->ScheduleInitiatePngEncoding();
-    } else if (mime_type_ == kMimeTypeJpeg) {
-      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)
-      NOTREACHED();
-    }
+    this->ScheduleInitiateEncoding(quality);
 
     // 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 the same thread.
     this->PostDelayedTaskToCurrentThread(
         BLINK_FROM_HERE,
         WTF::Bind(&CanvasAsyncBlobCreator::IdleTaskStartTimeoutEvent,
                   WrapPersistent(this), quality),
         kIdleTaskStartTimeoutDelay);
   }
 }
 
-void CanvasAsyncBlobCreator::ScheduleInitiateJpegEncoding(
-    const double& quality) {
+void CanvasAsyncBlobCreator::ScheduleInitiateEncoding(double quality) {
   schedule_initiate_start_time_ = WTF::MonotonicallyIncreasingTime();
   Platform::Current()->CurrentThread()->Scheduler()->PostIdleTask(
-      BLINK_FROM_HERE, WTF::Bind(&CanvasAsyncBlobCreator::InitiateJpegEncoding,
+      BLINK_FROM_HERE, WTF::Bind(&CanvasAsyncBlobCreator::InitiateEncoding,
                                  WrapPersistent(this), quality));
 }
 
-void CanvasAsyncBlobCreator::InitiateJpegEncoding(const double& quality,
-                                                  double deadline_seconds) {
+void CanvasAsyncBlobCreator::InitiateEncoding(double quality,
+                                              double deadline_seconds) {
   RecordElapsedTimeHistogram(
-      kInitiateEncodingDelay, kMimeTypeJpeg,
+      kInitiateEncodingDelay, mime_type_,
       WTF::MonotonicallyIncreasingTime() - schedule_initiate_start_time_);
   if (idle_task_status_ == kIdleTaskSwitchedToImmediateTask) {
     return;
   }
 
   DCHECK(idle_task_status_ == kIdleTaskNotStarted);
   idle_task_status_ = kIdleTaskStarted;
 
-  if (!InitializeJpegStruct(quality)) {
+  if (!InitializeEncoder(quality)) {
     idle_task_status_ = kIdleTaskFailed;
     return;
   }
-  this->IdleEncodeRowsJpeg(deadline_seconds);
+
+  this->IdleEncodeRows(deadline_seconds);
 }
 
-void CanvasAsyncBlobCreator::ScheduleInitiatePngEncoding() {
-  schedule_initiate_start_time_ = WTF::MonotonicallyIncreasingTime();
-  Platform::Current()->CurrentThread()->Scheduler()->PostIdleTask(
-      BLINK_FROM_HERE, WTF::Bind(&CanvasAsyncBlobCreator::InitiatePngEncoding,
-                                 WrapPersistent(this)));
-}
-
-void CanvasAsyncBlobCreator::InitiatePngEncoding(double deadline_seconds) {
-  RecordElapsedTimeHistogram(
-      kInitiateEncodingDelay, kMimeTypePng,
-      WTF::MonotonicallyIncreasingTime() - schedule_initiate_start_time_);
-  if (idle_task_status_ == kIdleTaskSwitchedToImmediateTask) {
-    return;
-  }
-
-  DCHECK(idle_task_status_ == kIdleTaskNotStarted);
-  idle_task_status_ = kIdleTaskStarted;
-
-  if (!InitializePngStruct()) {
-    idle_task_status_ = kIdleTaskFailed;
-    return;
-  }
-  this->IdleEncodeRowsPng(deadline_seconds);
-}
-
-void CanvasAsyncBlobCreator::IdleEncodeRowsPng(double deadline_seconds) {
+void CanvasAsyncBlobCreator::IdleEncodeRows(double deadline_seconds) {
   if (idle_task_status_ == kIdleTaskSwitchedToImmediateTask) {
     return;
   }
 
   double start_time = WTF::MonotonicallyIncreasingTime();
-  unsigned char* input_pixels =
-      data_->Data() + pixel_row_stride_ * num_rows_completed_;
-  for (int y = num_rows_completed_; y < size_.Height(); ++y) {
+  for (int y = num_rows_completed_; y < src_data_.height(); ++y) {
     if (IsDeadlineNearOrPassed(deadline_seconds)) {
       num_rows_completed_ = y;
       elapsed_time_ += (WTF::MonotonicallyIncreasingTime() - start_time);
       Platform::Current()->CurrentThread()->Scheduler()->PostIdleTask(
-          BLINK_FROM_HERE, WTF::Bind(&CanvasAsyncBlobCreator::IdleEncodeRowsPng,
+          BLINK_FROM_HERE, WTF::Bind(&CanvasAsyncBlobCreator::IdleEncodeRows,
                                      WrapPersistent(this)));
       return;
     }
-    PNGImageEncoder::WriteOneRowToPng(input_pixels, png_encoder_state_.get());
-    input_pixels += pixel_row_stride_;
+
+    if (!encoder_->encodeRows(1)) {
+      idle_task_status_ = kIdleTaskFailed;
+      this->CreateNullAndReturnResult();
+      return;
+    }
   }
-  num_rows_completed_ = size_.Height();
-  PNGImageEncoder::FinalizePng(png_encoder_state_.get());
+  num_rows_completed_ = src_data_.height();
 
   idle_task_status_ = kIdleTaskCompleted;
   elapsed_time_ += (WTF::MonotonicallyIncreasingTime() - start_time);
-  RecordElapsedTimeHistogram(kIdleEncodeDuration, kMimeTypePng, elapsed_time_);
+  RecordElapsedTimeHistogram(kIdleEncodeDuration, mime_type_, elapsed_time_);
   if (IsDeadlineNearOrPassed(deadline_seconds)) {
     TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
         ->PostTask(BLINK_FROM_HERE,
                    WTF::Bind(&CanvasAsyncBlobCreator::CreateBlobAndReturnResult,
                              WrapPersistent(this)));
   } else {
     this->CreateBlobAndReturnResult();
   }
 }
 
-void CanvasAsyncBlobCreator::IdleEncodeRowsJpeg(double deadline_seconds) {
-  if (idle_task_status_ == kIdleTaskSwitchedToImmediateTask) {
-    return;
-  }
-
-  double start_time = WTF::MonotonicallyIncreasingTime();
-  num_rows_completed_ = JPEGImageEncoder::ProgressiveEncodeRowsJpegHelper(
-      jpeg_encoder_state_.get(), data_->Data(), num_rows_completed_,
-      kSlackBeforeDeadline, deadline_seconds);
-  elapsed_time_ += (WTF::MonotonicallyIncreasingTime() - start_time);
-  if (num_rows_completed_ == size_.Height()) {
-    idle_task_status_ = kIdleTaskCompleted;
-    RecordElapsedTimeHistogram(kIdleEncodeDuration, kMimeTypeJpeg,
-                               elapsed_time_);
-
-    if (IsDeadlineNearOrPassed(deadline_seconds)) {
-      TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
-          ->PostTask(
-              BLINK_FROM_HERE,
-              WTF::Bind(&CanvasAsyncBlobCreator::CreateBlobAndReturnResult,
-                        WrapPersistent(this)));
-    } else {
-      this->CreateBlobAndReturnResult();
-    }
-  } else if (num_rows_completed_ ==
-             JPEGImageEncoder::kProgressiveEncodeFailed) {
-    idle_task_status_ = kIdleTaskFailed;
-    this->CreateNullAndReturnResult();
-  } else {
-    Platform::Current()->CurrentThread()->Scheduler()->PostIdleTask(
-        BLINK_FROM_HERE, WTF::Bind(&CanvasAsyncBlobCreator::IdleEncodeRowsJpeg,
-                                   WrapPersistent(this)));
-  }
-}
-
-void CanvasAsyncBlobCreator::ForceEncodeRowsPngOnCurrentThread() {
+void CanvasAsyncBlobCreator::ForceEncodeRowsOnCurrentThread() {
   DCHECK(idle_task_status_ == kIdleTaskSwitchedToImmediateTask);
 
   // Continue encoding from the last completed row
-  unsigned char* input_pixels =
-      data_->Data() + pixel_row_stride_ * num_rows_completed_;
-  for (int y = num_rows_completed_; y < size_.Height(); ++y) {
-    PNGImageEncoder::WriteOneRowToPng(input_pixels, png_encoder_state_.get());
-    input_pixels += pixel_row_stride_;
+  for (int y = num_rows_completed_; y < src_data_.height(); ++y) {
+    if (!encoder_->encodeRows(1)) {
+      idle_task_status_ = kIdleTaskFailed;
+      this->CreateNullAndReturnResult();
+      return;
+    }
   }
-  PNGImageEncoder::FinalizePng(png_encoder_state_.get());
+  num_rows_completed_ = src_data_.height();
 
   if (IsMainThread()) {
     this->CreateBlobAndReturnResult();
   } else {
     TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
         ->PostTask(
             BLINK_FROM_HERE,
             CrossThreadBind(&CanvasAsyncBlobCreator::CreateBlobAndReturnResult,
                             WrapCrossThreadPersistent(this)));
   }
 
   this->SignalAlternativeCodePathFinishedForTesting();
 }
 
-void CanvasAsyncBlobCreator::ForceEncodeRowsJpegOnCurrentThread() {
-  DCHECK(idle_task_status_ == kIdleTaskSwitchedToImmediateTask);
-
-  // Continue encoding from the last completed row
-  void (CanvasAsyncBlobCreator::*function_to_be_called)(void);
-  if (JPEGImageEncoder::EncodeWithPreInitializedState(
-          std::move(jpeg_encoder_state_), data_->Data(), num_rows_completed_)) {
-    function_to_be_called = &CanvasAsyncBlobCreator::CreateBlobAndReturnResult;
-  } else {
-    function_to_be_called = &CanvasAsyncBlobCreator::CreateNullAndReturnResult;
-  }
-
-  if (IsMainThread()) {
-    (this->*function_to_be_called)();
-  } else {
-    TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
-        ->PostTask(BLINK_FROM_HERE,
-                   CrossThreadBind(function_to_be_called,
-                                   WrapCrossThreadPersistent(this)));
-  }
-
-  this->SignalAlternativeCodePathFinishedForTesting();
-}
-
 void CanvasAsyncBlobCreator::CreateBlobAndReturnResult() {
   RecordIdleTaskStatusHistogram(idle_task_status_);
   RecordElapsedTimeHistogram(kToBlobDuration, mime_type_,
                              WTF::MonotonicallyIncreasingTime() - start_time_);
 
-  Blob* result_blob =
-      Blob::Create(encoded_image_->data(), encoded_image_->size(),
-                   ConvertMimeTypeEnumToString(mime_type_));
+  Blob* result_blob = Blob::Create(encoded_image_.data(), encoded_image_.size(),
+                                   ConvertMimeTypeEnumToString(mime_type_));
   if (function_type_ == kHTMLCanvasToBlobCallback) {
     TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
         ->PostTask(BLINK_FROM_HERE, WTF::Bind(&BlobCallback::handleEvent,
                                               WrapPersistent(callback_.Get()),
                                               WrapPersistent(result_blob)));
   } else {
     script_promise_resolver_->Resolve(result_blob);
   }
   // Avoid unwanted retention, see dispose().
   Dispose();
@@ skipping 13 matching lines @@
         kEncodingError, "Encoding of the source image has failed."));
   }
   // Avoid unwanted retention, see dispose().
   Dispose();
 }
 
 void CanvasAsyncBlobCreator::EncodeImageOnEncoderThread(double quality) {
   DCHECK(!IsMainThread());
   DCHECK(mime_type_ == kMimeTypeWebp);
 
-  if (!ImageDataBuffer(size_, data_->Data())
-           .EncodeImage("image/webp", quality, encoded_image_.get())) {
+  IntSize size(src_data_.width(), src_data_.height());
+  if (!ImageDataBuffer(size, data_->Data())
+           .EncodeImage("image/webp", quality, &encoded_image_)) {
     parent_frame_task_runner_->Get(TaskType::kCanvasBlobSerialization)
         ->PostTask(
             BLINK_FROM_HERE,
             CrossThreadBind(&CanvasAsyncBlobCreator::CreateNullAndReturnResult,
                             WrapCrossThreadPersistent(this)));
     return;
   }
 
   parent_frame_task_runner_->Get(TaskType::kCanvasBlobSerialization)
       ->PostTask(
           BLINK_FROM_HERE,
           CrossThreadBind(&CanvasAsyncBlobCreator::CreateBlobAndReturnResult,
                           WrapCrossThreadPersistent(this)));
 }
 
-bool CanvasAsyncBlobCreator::InitializePngStruct() {
-  png_encoder_state_ =
-      PNGImageEncoderState::Create(size_, encoded_image_.get());
-  if (!png_encoder_state_) {
-    this->CreateNullAndReturnResult();
-    return false;
+bool CanvasAsyncBlobCreator::InitializeEncoder(double quality) {
+  if (mime_type_ == kMimeTypeJpeg) {
+    SkJpegEncoder::Options options;
+    options.fQuality = ImageEncoder::ComputeJpegQuality(quality);
+    options.fAlphaOption = SkJpegEncoder::AlphaOption::kBlendOnBlack;
+    options.fBlendBehavior = SkTransferFunctionBehavior::kIgnore;
+    if (options.fQuality == 100) {
+      options.fDownsample = SkJpegEncoder::Downsample::k444;
+    }
+    encoder_ = ImageEncoder::Create(&encoded_image_, src_data_, options);
+  } 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)
+    DCHECK_EQ(kMimeTypePng, mime_type_);
+    SkPngEncoder::Options options;
+    options.fFilterFlags = SkPngEncoder::FilterFlag::kSub;
+    options.fZLibLevel = 3;
+    options.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
+    encoder_ = ImageEncoder::Create(&encoded_image_, src_data_, options);
   }
-  return true;
-}
 
-bool CanvasAsyncBlobCreator::InitializeJpegStruct(double quality) {
-  jpeg_encoder_state_ =
-      JPEGImageEncoderState::Create(size_, quality, encoded_image_.get());
-  if (!jpeg_encoder_state_) {
-    this->CreateNullAndReturnResult();
-    return false;
-  }
-  return true;
+  return encoder_.get();
 }
 
 void CanvasAsyncBlobCreator::IdleTaskStartTimeoutEvent(double quality) {
   if (idle_task_status_ == kIdleTaskStarted) {
     // Even if the task started quickly, we still want to ensure completion
     this->PostDelayedTaskToCurrentThread(
         BLINK_FROM_HERE,
         WTF::Bind(&CanvasAsyncBlobCreator::IdleTaskCompleteTimeoutEvent,
                   WrapPersistent(this)),
         kIdleTaskCompleteTimeoutDelay);
   } else if (idle_task_status_ == kIdleTaskNotStarted) {
     // 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.
     idle_task_status_ = kIdleTaskSwitchedToImmediateTask;
     SignalTaskSwitchInStartTimeoutEventForTesting();
 
-    if (mime_type_ == kMimeTypePng) {
-      if (InitializePngStruct()) {
-        TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
-            ->PostTask(
-                BLINK_FROM_HERE,
-                WTF::Bind(
-                    &CanvasAsyncBlobCreator::ForceEncodeRowsPngOnCurrentThread,
-                    WrapPersistent(this)));
-      } else {
-        // Failing in initialization of png struct
-        this->SignalAlternativeCodePathFinishedForTesting();
-      }
+    DCHECK(mime_type_ == kMimeTypePng || mime_type_ == kMimeTypeJpeg);
+    if (InitializeEncoder(quality)) {
+      TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
+          ->PostTask(
+              BLINK_FROM_HERE,
+              WTF::Bind(&CanvasAsyncBlobCreator::ForceEncodeRowsOnCurrentThread,
+                        WrapPersistent(this)));
     } else {
-      DCHECK(mime_type_ == kMimeTypeJpeg);
-      if (InitializeJpegStruct(quality)) {
-        TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
-            ->PostTask(
-                BLINK_FROM_HERE,
-                WTF::Bind(
-                    &CanvasAsyncBlobCreator::ForceEncodeRowsJpegOnCurrentThread,
-                    WrapPersistent(this)));
-      } else {
-        // Failing in initialization of jpeg struct
-        this->SignalAlternativeCodePathFinishedForTesting();
-      }
+      // Failing in initialization of encoder
+      this->SignalAlternativeCodePathFinishedForTesting();
     }
   } else {
     DCHECK(idle_task_status_ == kIdleTaskFailed ||
            idle_task_status_ == kIdleTaskCompleted);
     this->SignalAlternativeCodePathFinishedForTesting();
   }
 }
 
 void CanvasAsyncBlobCreator::IdleTaskCompleteTimeoutEvent() {
   DCHECK(idle_task_status_ != kIdleTaskNotStarted);
 
   if (idle_task_status_ == kIdleTaskStarted) {
     // It has taken too long to complete for the idle task.
     idle_task_status_ = kIdleTaskSwitchedToImmediateTask;
     SignalTaskSwitchInCompleteTimeoutEventForTesting();
 
-    if (mime_type_ == kMimeTypePng) {
-      TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
-          ->PostTask(
-              BLINK_FROM_HERE,
-              WTF::Bind(
-                  &CanvasAsyncBlobCreator::ForceEncodeRowsPngOnCurrentThread,
-                  WrapPersistent(this)));
-    } else {
-      DCHECK(mime_type_ == kMimeTypeJpeg);
-      TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
-          ->PostTask(
-              BLINK_FROM_HERE,
-              WTF::Bind(
-                  &CanvasAsyncBlobCreator::ForceEncodeRowsJpegOnCurrentThread,
-                  WrapPersistent(this)));
-    }
+    DCHECK(mime_type_ == kMimeTypePng || mime_type_ == kMimeTypeJpeg);
+    TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
+        ->PostTask(
+            BLINK_FROM_HERE,
+            WTF::Bind(&CanvasAsyncBlobCreator::ForceEncodeRowsOnCurrentThread,
+                      WrapPersistent(this)));
   } else {
     DCHECK(idle_task_status_ == kIdleTaskFailed ||
            idle_task_status_ == kIdleTaskCompleted);
     this->SignalAlternativeCodePathFinishedForTesting();
   }
 }
 
 void CanvasAsyncBlobCreator::PostDelayedTaskToCurrentThread(
     const WebTraceLocation& location,
     std::unique_ptr<WTF::Closure> task,
     double delay_ms) {
   TaskRunnerHelper::Get(TaskType::kCanvasBlobSerialization, document_)
       ->PostDelayedTask(location, std::move(task),
                         TimeDelta::FromMillisecondsD(delay_ms));
 }
 
 DEFINE_TRACE(CanvasAsyncBlobCreator) {
   visitor->Trace(document_);
   visitor->Trace(data_);
   visitor->Trace(callback_);
   visitor->Trace(parent_frame_task_runner_);
   visitor->Trace(script_promise_resolver_);
 }
 
 }  // namespace blink