Refactor ImageBitmap constructor from ImageData to be color managed

third_party/WebKit/Source/core/frame/ImageBitmap.cpp

 // Copyright 2013 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/frame/ImageBitmap.h"
 
 #include <memory>
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/offscreencanvas/OffscreenCanvas.h"
 #include "platform/graphics/CanvasColorParams.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "platform/wtf/CheckedNumeric.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/RefPtr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImageInfo.h"
 #include "third_party/skia/include/core/SkSurface.h"
+#include "third_party/skia/include/core/SkSwizzle.h"
 
 namespace blink {
 
 constexpr const char* kImageOrientationFlipY = "flipY";
 constexpr const char* kImageBitmapOptionNone = "none";
 constexpr const char* kImageBitmapOptionDefault = "default";
 constexpr const char* kImageBitmapOptionPremultiply = "premultiply";
 constexpr const char* kImageBitmapOptionResizeQualityHigh = "high";
 constexpr const char* kImageBitmapOptionResizeQualityMedium = "medium";
 constexpr const char* kImageBitmapOptionResizeQualityPixelated = "pixelated";
@@ skipping 114 matching lines @@
     parsed_options.resize_quality = kHigh_SkFilterQuality;
   else if (options.resizeQuality() == kImageBitmapOptionResizeQualityMedium)
     parsed_options.resize_quality = kMedium_SkFilterQuality;
   else if (options.resizeQuality() == kImageBitmapOptionResizeQualityPixelated)
     parsed_options.resize_quality = kNone_SkFilterQuality;
   else
     parsed_options.resize_quality = kLow_SkFilterQuality;
   return parsed_options;
 }
 
+// The function dstBufferSizeHasOverflow() is being called at the beginning of
+// each ImageBitmap() constructor, which makes sure that doing
+// width * height * bytesPerPixel will never overflow unsigned.
 bool DstBufferSizeHasOverflow(const ParsedOptions& options) {
   CheckedNumeric<unsigned> total_bytes = options.crop_rect.Width();
   total_bytes *= options.crop_rect.Height();
   total_bytes *=
       SkColorTypeBytesPerPixel(options.color_params.GetSkColorType());
   if (!total_bytes.IsValid())
     return true;
 
   if (!options.should_scale_input)
     return false;
   total_bytes = options.resize_width;
   total_bytes *= options.resize_height;
   total_bytes *=
       SkColorTypeBytesPerPixel(options.color_params.GetSkColorType());
   if (!total_bytes.IsValid())
     return true;
 
   return false;
 }
 
 }  // namespace
 
+static void PrintSkImage(sk_sp<SkImage> input) {
+  SkImageInfo info =
+      SkImageInfo::Make(input->width(), input->height(), kN32_SkColorType,
+                        kPremul_SkAlphaType, input->refColorSpace());
+  LOG(ERROR) << "Printing SkImage:" << input->width() << "," << input->height();
+  std::stringstream str;
+  std::unique_ptr<uint8_t[]> read_pixels(
+      new uint8_t[input->width() * input->height() * 4]());
+  input->readPixels(info, read_pixels.get(), input->width() * 4, 0, 0);
+  for (int i = 0; i < input->width() * input->height(); i++) {
+    if (i % input->width() == 0)
+      str << "\n";
+    str << "[";
+    for (int j = 0; j < 4; j++)
+      str << (int)(read_pixels[i * 4 + j]) << ",";
+    str << "] ";
+  }
+  LOG(ERROR) << str.str();
+}
+
 static PassRefPtr<Uint8Array> CopySkImageData(SkImage* input,
                                               const SkImageInfo& info) {
-  // The function dstBufferSizeHasOverflow() is being called at the beginning of
-  // each ImageBitmap() constructor, which makes sure that doing
-  // width * height * bytesPerPixel will never overflow unsigned.
   unsigned width = static_cast<unsigned>(input->width());
   RefPtr<ArrayBuffer> dst_buffer =
       ArrayBuffer::CreateOrNull(width * input->height(), info.bytesPerPixel());
   if (!dst_buffer)
     return nullptr;
   RefPtr<Uint8Array> dst_pixels =
       Uint8Array::Create(dst_buffer, 0, dst_buffer->ByteLength());
   input->readPixels(info, dst_pixels->Data(), width * info.bytesPerPixel(), 0,
                     0);
   return dst_pixels;
 }
 
 static sk_sp<SkImage> NewSkImageFromRaster(const SkImageInfo& info,
                                            PassRefPtr<Uint8Array> image_pixels,
                                            unsigned image_row_bytes) {
   SkPixmap pixmap(info, image_pixels->Data(), image_row_bytes);
   return SkImage::MakeFromRaster(pixmap,
                                  [](const void*, void* pixels) {
                                    static_cast<Uint8Array*>(pixels)->Deref();
                                  },
                                  image_pixels.LeakRef());
 }
 
-static void SwizzleImageData(unsigned char* src_addr,
-                             unsigned height,
-                             unsigned bytes_per_row,
-                             bool flip_y) {
-  if (flip_y) {
-    for (unsigned i = 0; i < height / 2; i++) {
-      unsigned top_row_start_position = i * bytes_per_row;
-      unsigned bottom_row_start_position = (height - 1 - i) * bytes_per_row;
-      if (kN32_SkColorType == kBGRA_8888_SkColorType) {  // needs to swizzle
-        for (unsigned j = 0; j < bytes_per_row; j += 4) {
-          std::swap(src_addr[top_row_start_position + j],
-                    src_addr[bottom_row_start_position + j + 2]);
-          std::swap(src_addr[top_row_start_position + j + 1],
-                    src_addr[bottom_row_start_position + j + 1]);
-          std::swap(src_addr[top_row_start_position + j + 2],
-                    src_addr[bottom_row_start_position + j]);
-          std::swap(src_addr[top_row_start_position + j + 3],
-                    src_addr[bottom_row_start_position + j + 3]);
-        }
-      } else {
-        std::swap_ranges(src_addr + top_row_start_position,
-                         src_addr + top_row_start_position + bytes_per_row,
-                         src_addr + bottom_row_start_position);
-      }
-    }
-  } else {
-    if (kN32_SkColorType == kBGRA_8888_SkColorType)  // needs to swizzle
-      for (unsigned i = 0; i < height * bytes_per_row; i += 4)
-        std::swap(src_addr[i], src_addr[i + 2]);
-  }
-}
-
 enum AlphaPremultiplyEnforcement {
   kEnforceAlphaPremultiply,
   kDontEnforceAlphaPremultiply,
 };
 
 static sk_sp<SkImage> FlipSkImageVertically(
     SkImage* input,
     AlphaPremultiplyEnforcement premultiply_enforcement =
         kDontEnforceAlphaPremultiply,
     const ParsedOptions& options = DefaultOptions()) {
@@ skipping 21 matching lines @@
                      image_pixels->Data() + bottom_first_element);
   }
   return NewSkImageFromRaster(info, std::move(image_pixels), image_row_bytes);
 }
 
 static sk_sp<SkImage> PremulSkImageToUnPremul(
     SkImage* input,
     const ParsedOptions& options = DefaultOptions()) {
   SkImageInfo info = SkImageInfo::Make(
       input->width(), input->height(), options.color_params.GetSkColorType(),
-      kUnpremul_SkAlphaType, input->refColorSpace());
+      kPremul_SkAlphaType, options.color_params.GetSkColorSpaceForSkSurfaces());
 
+  LOG(ERROR) << "Premul:";
+  std::stringstream str;
+  std::unique_ptr<uint8_t[]> read_pixels(new uint8_t[64]());
+  input->readPixels(info, read_pixels.get(), input->width() * 4, 0, 0);
+  for (int i = 0; i < 16; i++) {
+    str << "[";
+    for (int j = 0; j < 4; j++)
+      str << (int)(read_pixels[i * 4 + j]) << ",";
+    str << "] ";
+  }
+  LOG(ERROR) << str.str();
+
+  info = info.makeAlphaType(kUnpremul_SkAlphaType);
   RefPtr<Uint8Array> dst_pixels = CopySkImageData(input, info);
+  LOG(ERROR) << "Unpremul:";
+  str.str("");
+  for (int i = 0; i < 16; i++) {
+    str << "[";
+    for (int j = 0; j < 4; j++)
+      str << (int)(dst_pixels->Data()[i * 4 + j]) << ",";
+    str << "] ";
+  }
+  LOG(ERROR) << str.str();
+
   if (!dst_pixels)
     return nullptr;
   return NewSkImageFromRaster(
       info, std::move(dst_pixels),
       static_cast<unsigned>(input->width()) * info.bytesPerPixel());
 }
 
 static sk_sp<SkImage> UnPremulSkImageToPremul(
     SkImage* input,
     const ParsedOptions& options = DefaultOptions()) {
   SkImageInfo info = SkImageInfo::Make(
       input->width(), input->height(), options.color_params.GetSkColorType(),
       kPremul_SkAlphaType, input->refColorSpace());
 
   RefPtr<Uint8Array> dst_pixels = CopySkImageData(input, info);
   if (!dst_pixels)
     return nullptr;
   return NewSkImageFromRaster(
       info, std::move(dst_pixels),
       static_cast<unsigned>(input->width()) * info.bytesPerPixel());
 }
 
 static void ApplyColorSpaceConversion(sk_sp<SkImage>& image,
                                       ParsedOptions& options) {
   if (!options.color_canvas_extensions_enabled)
     return;
 
-  sk_sp<SkColorSpace> dst_color_space = nullptr;
-  SkColorType dst_color_type = kN32_SkColorType;
-  dst_color_space = options.color_params.GetSkColorSpace();
-  dst_color_type = options.color_params.GetSkColorType();
+  SkColorType dst_color_type = options.color_params.GetSkColorType();
+  sk_sp<SkColorSpace> dst_color_space = options.color_params.GetSkColorSpace();
   if (SkColorSpace::Equals(image->colorSpace(), dst_color_space.get()))
     return;
 
   SkImageInfo dst_info =
       SkImageInfo::Make(image->width(), image->height(), dst_color_type,
                         image->alphaType(), dst_color_space);
 
   size_t size = image->width() * image->height() * dst_info.bytesPerPixel();
   sk_sp<SkData> dst_data = SkData::MakeUninitialized(size);
   if (dst_data->size() != size)
     return;
   sk_sp<SkImage> colored_image = nullptr;
+  // The desired way to apply color space conversion on a SkImage is to use
+  // SkImage::readPixels.
   if (image->readPixels(dst_info, dst_data->writable_data(),
                         image->width() * dst_info.bytesPerPixel(), 0, 0)) {
     colored_image = SkImage::MakeRasterData(
         dst_info, dst_data, image->width() * dst_info.bytesPerPixel());
   } else {
-    // The desired way to apply color space conversion on a SkImage is to use
-    // SkImage::readPixels. However, if the SkImage is GPU-backed, readPixels
-    // still might not work properly. In this case, we fall back to drawing
-    // the SkImage to a canvas and reading back the result.
+    // However, if the SkImage is GPU-backed, readPixels might not work
+    // properly. In this case, we fall back to drawing the SkImage to a
+    // canvas and reading back the result.
     // Skia does not support drawing to unpremul surfaces/canvases.
     sk_sp<SkImage> un_premul_image = nullptr;
     if (image->alphaType() == kUnpremul_SkAlphaType) {
       un_premul_image = UnPremulSkImageToPremul(image.get(), options);
       dst_info = dst_info.makeAlphaType(kPremul_SkAlphaType);
     }
 
     // If the color space of the source SkImage is null, the following code
     // does not do any color conversion. This cannot be addressed here and
     // the code that creates the SkImage must tag the SkImage with proper
@@ skipping 61 matching lines @@
 // need to use the ImageDecoder to decode the image.
 static PassRefPtr<StaticBitmapImage> CropImageAndApplyColorSpaceConversion(
     Image* image,
     ParsedOptions& parsed_options,
     AlphaDisposition image_format,
     ColorBehavior color_behavior) {
   DCHECK(image);
   IntRect img_rect(IntPoint(), IntSize(image->width(), image->height()));
   const IntRect src_rect = Intersection(img_rect, parsed_options.crop_rect);
 
-  // In the case when cropRect doesn't intersect the source image and it
-  // requires a umpremul image We immediately return a transparent black image
-  // with cropRect.size()
-  if (src_rect.IsEmpty() && !parsed_options.premultiply_alpha) {
+  // In the case when cropRect doesn't intersect the source image, we
+  // return a transparent black image, respecting the color_params but
+  // ignoring premultiply_alpha.
+  if (src_rect.IsEmpty()) {
     SkImageInfo info = SkImageInfo::Make(
-        parsed_options.resize_width, parsed_options.resize_height,
-        kN32_SkColorType, kUnpremul_SkAlphaType);
-    RefPtr<ArrayBuffer> dst_buffer = ArrayBuffer::CreateOrNull(
-        static_cast<unsigned>(info.width()) * info.height(),
-        info.bytesPerPixel());
-    if (!dst_buffer)
+        parsed_options.crop_rect.Width(), parsed_options.crop_rect.Height(),
+        parsed_options.color_params.GetSkColorType(), kPremul_SkAlphaType,
+        parsed_options.color_params.GetSkColorSpace());
+    if (parsed_options.should_scale_input) {
+      info = info.makeWH(parsed_options.resize_width,
+                         parsed_options.resize_height);
+    }
+    sk_sp<SkSurface> surface = SkSurface::MakeRaster(info);
+    if (!surface)
       return nullptr;
-    RefPtr<Uint8Array> dst_pixels =
-        Uint8Array::Create(dst_buffer, 0, dst_buffer->ByteLength());
-    return StaticBitmapImage::Create(NewSkImageFromRaster(
-        info, std::move(dst_pixels),
-        static_cast<unsigned>(info.width()) * info.bytesPerPixel()));
+    return StaticBitmapImage::Create(surface->makeImageSnapshot());
   }
 
   sk_sp<SkImage> skia_image = image->ImageForCurrentFrame();
-  // Attempt to get raw unpremultiplied image data, executed only when skiaImage
-  // is premultiplied.
+  // Attempt to get raw unpremultiplied image data, executed only when
+  // skia_image is premultiplied.
   if ((((!parsed_options.premultiply_alpha && !skia_image->isOpaque()) ||
         !skia_image) &&
        image->Data() && image_format == kPremultiplyAlpha) ||
       color_behavior.IsIgnore()) {
+    LOG(ERROR) << "HERE...";
     std::unique_ptr<ImageDecoder> decoder(ImageDecoder::Create(
         image->Data(), true,
         parsed_options.premultiply_alpha ? ImageDecoder::kAlphaPremultiplied
                                          : ImageDecoder::kAlphaNotPremultiplied,
         color_behavior));
     if (!decoder)
       return nullptr;
     SkColorType color_type = parsed_options.color_params.GetSkColorType();
     sk_sp<SkColorSpace> color_space =
         parsed_options.color_params.GetSkColorSpace();
     skia_image = ImageBitmap::GetSkImageFromDecoder(
         std::move(decoder), &color_type, &color_space,
         kUpdateColorSpaceInformation);
     if (!skia_image)
       return nullptr;
   }
 
-  if (parsed_options.crop_rect == src_rect &&
-      !parsed_options.should_scale_input) {
+  if (!parsed_options.should_scale_input) {
     sk_sp<SkImage> cropped_sk_image = skia_image->makeSubset(src_rect);
     ApplyColorSpaceConversion(cropped_sk_image, parsed_options);
     if (parsed_options.flip_y) {
       return StaticBitmapImage::Create(
           FlipSkImageVertically(cropped_sk_image.get(),
                                 kDontEnforceAlphaPremultiply, parsed_options));
     }
     // Special case: The first parameter image is unpremul but we need to turn
     // it into premul.
     if (parsed_options.premultiply_alpha &&
         image_format == kDontPremultiplyAlpha) {
       return StaticBitmapImage::Create(
           UnPremulSkImageToPremul(cropped_sk_image.get()));
     }
     return StaticBitmapImage::Create(std::move(cropped_sk_image));
   }
 
-  sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(
-      parsed_options.resize_width, parsed_options.resize_height);
+  LOG(ERROR) << "HERE...";
+  SkImageInfo info = SkImageInfo::Make(
+      parsed_options.resize_width, parsed_options.resize_height,
+      parsed_options.color_params.GetSkColorType(),
+      parsed_options.premultiply_alpha ? kPremul_SkAlphaType
+                                       : kUnpremul_SkAlphaType,
+      parsed_options.color_params.GetSkColorSpace());
+  sk_sp<SkSurface> surface = SkSurface::MakeRaster(info);
   if (!surface)
     return nullptr;
-  if (src_rect.IsEmpty())
-    return StaticBitmapImage::Create(surface->makeImageSnapshot());
-
-  SkScalar dst_left = std::min(0, -parsed_options.crop_rect.X());
-  SkScalar dst_top = std::min(0, -parsed_options.crop_rect.Y());
-  if (parsed_options.crop_rect.X() < 0)
-    dst_left = -parsed_options.crop_rect.X();
-  if (parsed_options.crop_rect.Y() < 0)
-    dst_top = -parsed_options.crop_rect.Y();
   if (parsed_options.flip_y) {
     surface->getCanvas()->translate(0, surface->height());
     surface->getCanvas()->scale(1, -1);
   }
-  if (parsed_options.should_scale_input) {
-    SkRect draw_src_rect = SkRect::MakeXYWH(
-        parsed_options.crop_rect.X(), parsed_options.crop_rect.Y(),
-        parsed_options.crop_rect.Width(), parsed_options.crop_rect.Height());
-    SkRect draw_dst_rect = SkRect::MakeXYWH(0, 0, parsed_options.resize_width,
-                                            parsed_options.resize_height);
-    SkPaint paint;
-    paint.setFilterQuality(parsed_options.resize_quality);
-    surface->getCanvas()->drawImageRect(skia_image, draw_src_rect,
-                                        draw_dst_rect, &paint);
-  } else {
-    surface->getCanvas()->drawImage(skia_image, dst_left, dst_top);
-  }
+
+  SkRect draw_src_rect(parsed_options.crop_rect);
+  SkRect draw_dst_rect =
+      SkRect::MakeWH(parsed_options.resize_width, parsed_options.resize_height);
+  SkPaint paint;
+  paint.setFilterQuality(parsed_options.resize_quality);
+  surface->getCanvas()->drawImageRect(skia_image, draw_src_rect, draw_dst_rect,
+                                      &paint);
+
   skia_image = surface->makeImageSnapshot();
+  PrintSkImage(skia_image);
   ApplyColorSpaceConversion(skia_image, parsed_options);
+  PrintSkImage(skia_image);
 
   if (parsed_options.premultiply_alpha) {
+    LOG(ERROR) << "HERE";
     if (image_format == kDontPremultiplyAlpha)
       return StaticBitmapImage::Create(
           UnPremulSkImageToPremul(skia_image.get()));
     return StaticBitmapImage::Create(std::move(skia_image));
   }
-  return StaticBitmapImage::Create(PremulSkImageToUnPremul(skia_image.get()));
+  LOG(ERROR) << "HERE";
+  return StaticBitmapImage::Create(std::move(skia_image));
+  // return StaticBitmapImage::Create(
+  //     PremulSkImageToUnPremul(skia_image.get(), parsed_options));
 }
 
 ImageBitmap::ImageBitmap(ImageElementBase* image,
                          Optional<IntRect> crop_rect,
                          Document* document,
                          const ImageBitmapOptions& options) {
+  LOG(ERROR) << "Entering...";
   RefPtr<Image> input = image->CachedImage()->GetImage();
   ParsedOptions parsed_options =
       ParseOptions(options, crop_rect, image->BitmapSourceSize());
   if (DstBufferSizeHasOverflow(parsed_options))
     return;
 
   if (options.colorSpaceConversion() == kImageBitmapOptionNone) {
     image_ = CropImageAndApplyColorSpaceConversion(input.Get(), parsed_options,
                                                    kPremultiplyAlpha,
                                                    ColorBehavior::Ignore());
@@ skipping 27 matching lines @@
     return;
   image_->SetOriginClean(
       !image->WouldTaintOrigin(document->GetSecurityOrigin()));
   image_->SetPremultiplied(parsed_options.premultiply_alpha);
 }
 
 ImageBitmap::ImageBitmap(HTMLVideoElement* video,
                          Optional<IntRect> crop_rect,
                          Document* document,
                          const ImageBitmapOptions& options) {
+  LOG(ERROR) << "Entering...";
   IntSize player_size;
   if (video->GetWebMediaPlayer())
     player_size = video->GetWebMediaPlayer()->NaturalSize();
   ParsedOptions parsed_options =
       ParseOptions(options, crop_rect, video->BitmapSourceSize());
   if (DstBufferSizeHasOverflow(parsed_options))
     return;
 
   std::unique_ptr<ImageBuffer> buffer = ImageBuffer::Create(
       IntSize(parsed_options.resize_width, parsed_options.resize_height),
@@ skipping 18 matching lines @@
   }
   buffer->Canvas()->translate(dst_point.X(), dst_point.Y());
   video->PaintCurrentFrame(
       buffer->Canvas(),
       IntRect(IntPoint(), IntSize(video->videoWidth(), video->videoHeight())),
       parsed_options.should_scale_input ? &flags : nullptr);
 
   sk_sp<SkImage> skia_image =
       buffer->NewSkImageSnapshot(kPreferNoAcceleration, kSnapshotReasonUnknown);
   if (!parsed_options.premultiply_alpha)
-    skia_image = PremulSkImageToUnPremul(skia_image.get());
+    skia_image = PremulSkImageToUnPremul(skia_image.get(), parsed_options);
   if (!skia_image)
     return;
   image_ = StaticBitmapImage::Create(std::move(skia_image));
   image_->SetOriginClean(
       !video->WouldTaintOrigin(document->GetSecurityOrigin()));
   image_->SetPremultiplied(parsed_options.premultiply_alpha);
 }
 
 ImageBitmap::ImageBitmap(HTMLCanvasElement* canvas,
                          Optional<IntRect> crop_rect,
                          const ImageBitmapOptions& options) {
+  LOG(ERROR) << "Entering...";
   DCHECK(canvas->IsPaintable());
   RefPtr<Image> input;
   if (canvas->PlaceholderFrame()) {
     input = canvas->PlaceholderFrame();
   } else {
     input = canvas->CopiedImage(kBackBuffer, kPreferAcceleration,
                                 kSnapshotReasonCreateImageBitmap);
   }
   ParsedOptions parsed_options = ParseOptions(
       options, crop_rect, IntSize(input->width(), input->height()));
   if (DstBufferSizeHasOverflow(parsed_options))
     return;
 
   bool is_premultiply_alpha_reverted = false;
   if (!parsed_options.premultiply_alpha) {
     parsed_options.premultiply_alpha = true;
     is_premultiply_alpha_reverted = true;
   }
   image_ = CropImageAndApplyColorSpaceConversion(
       input.Get(), parsed_options, kPremultiplyAlpha,
       ColorBehavior::TransformToGlobalTarget());
   if (!image_)
     return;
   if (is_premultiply_alpha_reverted) {
     parsed_options.premultiply_alpha = false;
-    image_ = StaticBitmapImage::Create(
-        PremulSkImageToUnPremul(image_->ImageForCurrentFrame().get()));
+    image_ = StaticBitmapImage::Create(PremulSkImageToUnPremul(
+        image_->ImageForCurrentFrame().get(), parsed_options));
   }
   if (!image_)
     return;
   image_->SetOriginClean(canvas->OriginClean());
   image_->SetPremultiplied(parsed_options.premultiply_alpha);
 }
 
 ImageBitmap::ImageBitmap(OffscreenCanvas* offscreen_canvas,
                          Optional<IntRect> crop_rect,
                          const ImageBitmapOptions& options) {
+  LOG(ERROR) << "Entering...";
   SourceImageStatus status;
   RefPtr<Image> input = offscreen_canvas->GetSourceImageForCanvas(
       &status, kPreferNoAcceleration, kSnapshotReasonCreateImageBitmap,
       FloatSize(offscreen_canvas->Size()));
   if (status != kNormalSourceImageStatus)
     return;
   ParsedOptions parsed_options = ParseOptions(
       options, crop_rect, IntSize(input->width(), input->height()));
   if (DstBufferSizeHasOverflow(parsed_options))
     return;
 
   bool is_premultiply_alpha_reverted = false;
   if (!parsed_options.premultiply_alpha) {
     parsed_options.premultiply_alpha = true;
     is_premultiply_alpha_reverted = true;
   }
   image_ = CropImageAndApplyColorSpaceConversion(
       input.Get(), parsed_options, kPremultiplyAlpha,
       ColorBehavior::TransformToGlobalTarget());
   if (!image_)
     return;
   if (is_premultiply_alpha_reverted) {
     parsed_options.premultiply_alpha = false;
-    image_ = StaticBitmapImage::Create(
-        PremulSkImageToUnPremul(image_->ImageForCurrentFrame().get()));
+    image_ = StaticBitmapImage::Create(PremulSkImageToUnPremul(
+        image_->ImageForCurrentFrame().get(), parsed_options));
   }
   if (!image_)
     return;
   image_->SetOriginClean(offscreen_canvas->OriginClean());
   image_->SetPremultiplied(parsed_options.premultiply_alpha);
 }
 
 ImageBitmap::ImageBitmap(const void* pixel_data,
                          uint32_t width,
                          uint32_t height,
                          bool is_image_bitmap_premultiplied,
                          bool is_image_bitmap_origin_clean) {
+  LOG(ERROR) << "Entering...";
   SkImageInfo info = SkImageInfo::MakeN32(width, height,
                                           is_image_bitmap_premultiplied
                                               ? kPremul_SkAlphaType
                                               : kUnpremul_SkAlphaType);
   SkPixmap pixmap(info, pixel_data, info.bytesPerPixel() * width);
   image_ = StaticBitmapImage::Create(SkImage::MakeRasterCopy(pixmap));
   if (!image_)
     return;
   image_->SetPremultiplied(is_image_bitmap_premultiplied);
   image_->SetOriginClean(is_image_bitmap_origin_clean);
 }
 
 static sk_sp<SkImage> ScaleSkImage(sk_sp<SkImage> sk_image,
+                                   const SkImageInfo& sk_image_info,
                                    unsigned resize_width,
                                    unsigned resize_height,
-                                   SkFilterQuality resize_quality,
-                                   SkColorType color_type = kN32_SkColorType,
-                                   sk_sp<SkColorSpace> color_space = nullptr) {
-  SkImageInfo resized_info =
-      SkImageInfo::Make(resize_width, resize_height, color_type,
-                        kUnpremul_SkAlphaType, color_space);
+                                   SkFilterQuality resize_quality) {
+  SkImageInfo resized_info = sk_image_info.makeWH(resize_width, resize_height);
   RefPtr<ArrayBuffer> dst_buffer = ArrayBuffer::CreateOrNull(
       resize_width * resize_height, resized_info.bytesPerPixel());
   if (!dst_buffer)
     return nullptr;
 
-  if (color_type == kN32_SkColorType) {
-    RefPtr<Uint8Array> resized_pixels =
-        Uint8Array::Create(dst_buffer, 0, dst_buffer->ByteLength());
-    SkPixmap pixmap(
-        resized_info, resized_pixels->Data(),
-        static_cast<unsigned>(resize_width) * resized_info.bytesPerPixel());
-    sk_image->scalePixels(pixmap, resize_quality);
-    return SkImage::MakeFromRaster(pixmap,
-                                   [](const void*, void* pixels) {
-                                     static_cast<Uint8Array*>(pixels)->Deref();
-                                   },
-                                   resized_pixels.LeakRef());
-  }
-
-  RefPtr<Float32Array> resized_pixels =
-      Float32Array::Create(dst_buffer, 0, dst_buffer->ByteLength());
+  RefPtr<Uint8Array> resized_pixels =
+      Uint8Array::Create(dst_buffer, 0, dst_buffer->ByteLength());
   SkPixmap pixmap(
       resized_info, resized_pixels->Data(),
       static_cast<unsigned>(resize_width) * resized_info.bytesPerPixel());
   sk_image->scalePixels(pixmap, resize_quality);
   return SkImage::MakeFromRaster(pixmap,
                                  [](const void*, void* pixels) {
-                                   static_cast<Float32Array*>(pixels)->Deref();
+                                   static_cast<Uint8Array*>(pixels)->Deref();
                                  },
                                  resized_pixels.LeakRef());
 }
 
+static void SwizzleImageData(ImageData* data, bool needs_swizzle) {
+  needs_swizzle = false;
+  if (data && needs_swizzle) {
+    SkSwapRB(reinterpret_cast<uint32_t*>(data->data()->Data()),
+             reinterpret_cast<uint32_t*>(data->data()->Data()),
+             data->Size().Height() * data->Size().Width());
+  }
+}
+
 ImageBitmap::ImageBitmap(ImageData* data,
                          Optional<IntRect> crop_rect,
                          const ImageBitmapOptions& options) {
-  // TODO(xidachen): implement the resize option
-  IntRect data_src_rect = IntRect(IntPoint(), data->Size());
+  LOG(ERROR) << "Entering...";
   ParsedOptions parsed_options =
       ParseOptions(options, crop_rect, data->BitmapSourceSize());
   if (DstBufferSizeHasOverflow(parsed_options))
     return;
+
+  IntRect data_src_rect = IntRect(IntPoint(), data->Size());
   IntRect src_rect = crop_rect
                          ? Intersection(parsed_options.crop_rect, data_src_rect)
                          : data_src_rect;
+  SkImageInfo unpremul_info = SkImageInfo::Make(
+      src_rect.Width(), src_rect.Height(),
+      parsed_options.color_params.GetSkColorType(), kUnpremul_SkAlphaType,
+      parsed_options.color_params.GetSkColorSpaceForSkSurfaces());
+  // if src_rect is empty, create an empty image bitmap with the requested size
+  // and return
+  if (src_rect.IsEmpty()) {
+    SkImageInfo info = parsed_options.premultiply_alpha
+                           ? unpremul_info.makeAlphaType(kPremul_SkAlphaType)
+                           : unpremul_info;
+    if (parsed_options.should_scale_input) {
+      info = info.makeWH(parsed_options.resize_width,
+                         parsed_options.resize_height);
+    } else if (crop_rect) {
+      info = info.makeWH(crop_rect->Width(), crop_rect->Height());
+    } else {
+      info = info.makeWH(data->Size().Width(), data->Size().Height());
+    }
+    unsigned bytes_per_row =
+        info.width() * parsed_options.color_params.BytesPerPixel();
+    std::unique_ptr<uint8_t[]> pixels(
+        new uint8_t[info.height() * bytes_per_row]);
+    memset(pixels.get(), 0, info.height() * bytes_per_row);
+    sk_sp<SkImage> sk_image =
+        SkImage::MakeRasterCopy(SkPixmap(info, pixels.get(), bytes_per_row));
+    image_ = StaticBitmapImage::Create(sk_image);
+    image_->SetPremultiplied(parsed_options.premultiply_alpha);
+    return;
+  }
+
+  // crop/flip the input and swizzle if needed. we swizzle back later if the
+  // input ImageData is swizzled here.
+  bool crop_or_flip = (src_rect != data_src_rect) || parsed_options.flip_y;
+  bool needs_swizzle =
+      parsed_options.color_params.GetSkColorType() == kBGRA_8888_SkColorType;
+  ImageData* cropped_data = data;
+  if (crop_or_flip)
+    cropped_data = data->CropRect(src_rect, parsed_options.flip_y);
+  SwizzleImageData(cropped_data, needs_swizzle);
+  unsigned bytes_per_row =
+      src_rect.Size().Width() * parsed_options.color_params.BytesPerPixel();
+  unsigned data_size = src_rect.Size().Height() * bytes_per_row;
+  // color convert the pixels if needed
+  unsigned char* color_corrected_pixels = cropped_data->data()->Data();
+  std::unique_ptr<uint8_t[]>* converted_pixels = nullptr;
+  if (!SkColorSpace::Equals(
+          cropped_data->GetCanvasColorParams()
+              .GetSkColorSpaceForSkSurfaces()
+              .get(),
+          parsed_options.color_params.GetSkColorSpaceForSkSurfaces().get()) ||
+      cropped_data->GetCanvasColorParams().GetSkColorType() ==
+          kRGBA_F16_SkColorType) {
+    converted_pixels = new std::unique_ptr<uint8_t[]>(new uint8_t[data_size]);
+    cropped_data->ImageDataInCanvasColorSettings(parsed_options.color_params,
+                                                 *converted_pixels);
+    color_corrected_pixels = converted_pixels->get();
+  }
 
   // treat non-premultiplyAlpha as a special case
   if (!parsed_options.premultiply_alpha) {
-    unsigned char* src_addr = data->data()->Data();
+    SkImageInfo info = unpremul_info.makeColorType(kRGBA_8888_SkColorType);
+    sk_sp<SkImage> sk_image = SkImage::MakeRasterCopy(
+        SkPixmap(info, color_corrected_pixels, bytes_per_row));
 
-    // Using kN32 type, swizzle input if necessary.
-    SkImageInfo info = SkImageInfo::Make(
-        parsed_options.crop_rect.Width(), parsed_options.crop_rect.Height(),
-        kN32_SkColorType, kUnpremul_SkAlphaType, data->GetSkColorSpace());
-    unsigned bytes_per_pixel = static_cast<unsigned>(info.bytesPerPixel());
-    unsigned src_pixel_bytes_per_row = bytes_per_pixel * data->Size().Width();
-    unsigned dst_pixel_bytes_per_row =
-        bytes_per_pixel * parsed_options.crop_rect.Width();
-    sk_sp<SkImage> sk_image;
-    if (parsed_options.crop_rect == IntRect(IntPoint(), data->Size())) {
-      SwizzleImageData(src_addr, data->Size().Height(), src_pixel_bytes_per_row,
-                       parsed_options.flip_y);
-      sk_image = SkImage::MakeRasterCopy(
-          SkPixmap(info, src_addr, dst_pixel_bytes_per_row));
-      // restore the original ImageData
-      SwizzleImageData(src_addr, data->Size().Height(), src_pixel_bytes_per_row,
-                       parsed_options.flip_y);
-    } else {
-      RefPtr<ArrayBuffer> dst_buffer = ArrayBuffer::CreateOrNull(
-          static_cast<unsigned>(parsed_options.crop_rect.Height()) *
-              parsed_options.crop_rect.Width(),
-          bytes_per_pixel);
-      if (!dst_buffer)
-        return;
-      RefPtr<Uint8Array> copied_data_buffer =
-          Uint8Array::Create(dst_buffer, 0, dst_buffer->ByteLength());
-      if (!src_rect.IsEmpty()) {
-        IntPoint src_point = IntPoint(
-            (parsed_options.crop_rect.X() > 0) ? parsed_options.crop_rect.X()
-                                               : 0,
-            (parsed_options.crop_rect.Y() > 0) ? parsed_options.crop_rect.Y()
-                                               : 0);
-        IntPoint dst_point = IntPoint((parsed_options.crop_rect.X() >= 0)
-                                          ? 0
-                                          : -parsed_options.crop_rect.X(),
-                                      (parsed_options.crop_rect.Y() >= 0)
-                                          ? 0
-                                          : -parsed_options.crop_rect.Y());
-        int copy_height = data->Size().Height() - src_point.Y();
-        if (parsed_options.crop_rect.Height() < copy_height)
-          copy_height = parsed_options.crop_rect.Height();
-        int copy_width = data->Size().Width() - src_point.X();
-        if (parsed_options.crop_rect.Width() < copy_width)
-          copy_width = parsed_options.crop_rect.Width();
-        for (int i = 0; i < copy_height; i++) {
-          unsigned src_start_copy_position =
-              (i + src_point.Y()) * src_pixel_bytes_per_row +
-              src_point.X() * bytes_per_pixel;
-          unsigned src_end_copy_position =
-              src_start_copy_position + copy_width * bytes_per_pixel;
-          unsigned dst_start_copy_position;
-          if (parsed_options.flip_y)
-            dst_start_copy_position =
-                (parsed_options.crop_rect.Height() - 1 - dst_point.Y() - i) *
-                    dst_pixel_bytes_per_row +
-                dst_point.X() * bytes_per_pixel;
-          else
-            dst_start_copy_position =
-                (dst_point.Y() + i) * dst_pixel_bytes_per_row +
-                dst_point.X() * bytes_per_pixel;
-          for (unsigned j = 0;
-               j < src_end_copy_position - src_start_copy_position; j++) {
-            // swizzle when necessary
-            if (kN32_SkColorType == kBGRA_8888_SkColorType) {
-              if (j % 4 == 0)
-                copied_data_buffer->Data()[dst_start_copy_position + j] =
-                    src_addr[src_start_copy_position + j + 2];
-              else if (j % 4 == 2)
-                copied_data_buffer->Data()[dst_start_copy_position + j] =
-                    src_addr[src_start_copy_position + j - 2];
-              else
-                copied_data_buffer->Data()[dst_start_copy_position + j] =
-                    src_addr[src_start_copy_position + j];
-            } else {
-              copied_data_buffer->Data()[dst_start_copy_position + j] =
-                  src_addr[src_start_copy_position + j];
-            }
-          }
-        }
-      }
-      sk_image = NewSkImageFromRaster(info, std::move(copied_data_buffer),
-                                      dst_pixel_bytes_per_row);
-    }
-    if (!sk_image)
-      return;
-    ApplyColorSpaceConversion(sk_image, parsed_options);
     if (parsed_options.should_scale_input) {
       image_ = StaticBitmapImage::Create(ScaleSkImage(
-          sk_image, parsed_options.resize_width, parsed_options.resize_height,
-          parsed_options.resize_quality,
-          parsed_options.color_params.GetSkColorType(),
-          data->GetSkColorSpace()));
+          sk_image, info, parsed_options.resize_width,
+          parsed_options.resize_height, parsed_options.resize_quality));
     } else {
       image_ = StaticBitmapImage::Create(sk_image);
     }
     if (!image_)
       return;
     image_->SetPremultiplied(parsed_options.premultiply_alpha);
+    SwizzleImageData(cropped_data, needs_swizzle);
     return;
   }
 
-  CanvasColorParams canvas_color_params;
-  if (RuntimeEnabledFeatures::colorCanvasExtensionsEnabled()) {
-    ImageDataColorSettings color_settings;
-    data->getColorSettings(color_settings);
-    CanvasColorSpace canvas_color_space =
-        ImageData::GetCanvasColorSpace(color_settings.colorSpace());
-    CanvasPixelFormat canvas_pixel_format = kRGBA8CanvasPixelFormat;
-    if (ImageData::GetImageDataStorageFormat(color_settings.storageFormat()) !=
-        kUint8ClampedArrayStorageFormat) {
-      canvas_pixel_format = kF16CanvasPixelFormat;
-    }
-    canvas_color_params =
-        CanvasColorParams(canvas_color_space, canvas_pixel_format);
-  }
+  IntSize buffer_size =
+      src_rect.IsEmpty() ? parsed_options.crop_rect.Size() : src_rect.Size();
   std::unique_ptr<ImageBuffer> buffer =
-      ImageBuffer::Create(parsed_options.crop_rect.Size(), kNonOpaque,
-                          kDoNotInitializeImagePixels, canvas_color_params);
+      ImageBuffer::Create(buffer_size, kNonOpaque, kDoNotInitializeImagePixels,
+                          parsed_options.color_params);
   if (!buffer)
     return;
-
   if (src_rect.IsEmpty()) {
     image_ = StaticBitmapImage::Create(buffer->NewSkImageSnapshot(
         kPreferNoAcceleration, kSnapshotReasonUnknown));
     return;
   }
 
-  IntPoint dst_point = IntPoint(std::min(0, -parsed_options.crop_rect.X()),
-                                std::min(0, -parsed_options.crop_rect.Y()));
-  if (parsed_options.crop_rect.X() < 0)
-    dst_point.SetX(-parsed_options.crop_rect.X());
-  if (parsed_options.crop_rect.Y() < 0)
-    dst_point.SetY(-parsed_options.crop_rect.Y());
+  buffer->PutByteArray(kUnmultiplied, color_corrected_pixels,
+                       cropped_data->Size(),
+                       IntRect(IntPoint(), cropped_data->Size()), IntPoint());
 
-  buffer->PutByteArray(kUnmultiplied, data->data()->Data(), data->Size(),
-                       src_rect, dst_point);
+  SwizzleImageData(cropped_data, needs_swizzle);
   sk_sp<SkImage> sk_image =
       buffer->NewSkImageSnapshot(kPreferNoAcceleration, kSnapshotReasonUnknown);
-  if (parsed_options.flip_y)
-    sk_image = FlipSkImageVertically(sk_image.get(), kEnforceAlphaPremultiply);
   if (!sk_image)
     return;
+
   if (parsed_options.should_scale_input) {
     sk_sp<SkSurface> surface = SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(
         parsed_options.resize_width, parsed_options.resize_height,
-        data->GetSkColorSpace()));
+        data->GetCanvasColorParams().GetSkColorSpaceForSkSurfaces()));
     if (!surface)
       return;
     SkPaint paint;
     paint.setFilterQuality(parsed_options.resize_quality);
     SkRect dst_draw_rect = SkRect::MakeWH(parsed_options.resize_width,
                                           parsed_options.resize_height);
     surface->getCanvas()->drawImageRect(sk_image, dst_draw_rect, &paint);
     sk_image = surface->makeImageSnapshot();
   }
-  ApplyColorSpaceConversion(sk_image, parsed_options);
   image_ = StaticBitmapImage::Create(std::move(sk_image));
 }
 
 ImageBitmap::ImageBitmap(ImageBitmap* bitmap,
                          Optional<IntRect> crop_rect,
                          const ImageBitmapOptions& options) {
+  LOG(ERROR) << "Entering...";
   RefPtr<Image> input = bitmap->BitmapImage();
   if (!input)
     return;
   ParsedOptions parsed_options =
       ParseOptions(options, crop_rect, input->Size());
   if (DstBufferSizeHasOverflow(parsed_options))
     return;
 
   image_ = CropImageAndApplyColorSpaceConversion(
       input.Get(), parsed_options,
       bitmap->IsPremultiplied() ? kPremultiplyAlpha : kDontPremultiplyAlpha,
       ColorBehavior::TransformToGlobalTarget());
   if (!image_)
     return;
   image_->SetOriginClean(bitmap->OriginClean());
   image_->SetPremultiplied(parsed_options.premultiply_alpha);
 }
 
 ImageBitmap::ImageBitmap(RefPtr<StaticBitmapImage> image,
                          Optional<IntRect> crop_rect,
                          const ImageBitmapOptions& options) {
+  LOG(ERROR) << "Entering... ";
   bool origin_clean = image->OriginClean();
   ParsedOptions parsed_options =
       ParseOptions(options, crop_rect, image->Size());
   if (DstBufferSizeHasOverflow(parsed_options))
     return;
 
+  LOG(ERROR) << "parsed_options.premultiply_alpha: "
+             << parsed_options.premultiply_alpha;
+  PrintSkImage(image.Get()->ImageForCurrentFrame());
+
   image_ = CropImageAndApplyColorSpaceConversion(
       image.Get(), parsed_options, kPremultiplyAlpha,
       ColorBehavior::TransformToGlobalTarget());
+  LOG(ERROR) << "HERE";
   if (!image_)
     return;
+  LOG(ERROR) << "HERE";
+
+  PrintSkImage(image_.Get()->ImageForCurrentFrame());
 
   image_->SetOriginClean(origin_clean);
   image_->SetPremultiplied(parsed_options.premultiply_alpha);
 }
 
 ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image) {
+  LOG(ERROR) << "Entering...";
   image_ = std::move(image);
 }
 
 PassRefPtr<StaticBitmapImage> ImageBitmap::Transfer() {
   DCHECK(!IsNeutered());
   is_neutered_ = true;
   image_->Transfer();
   return std::move(image_);
 }
 
@@ skipping 64 matching lines @@
   is_neutered_ = true;
 }
 
 // static
 ImageBitmap* ImageBitmap::Take(ScriptPromiseResolver*, sk_sp<SkImage> image) {
   return ImageBitmap::Create(StaticBitmapImage::Create(std::move(image)));
 }
 
 PassRefPtr<Uint8Array> ImageBitmap::CopyBitmapData(AlphaDisposition alpha_op,
                                                    DataColorFormat format) {
+  LOG(ERROR) << "Entering...";
   SkImageInfo info = SkImageInfo::Make(
       width(), height(),
       (format == kRGBAColorType) ? kRGBA_8888_SkColorType : kN32_SkColorType,
       (alpha_op == kPremultiplyAlpha) ? kPremul_SkAlphaType
                                       : kUnpremul_SkAlphaType);
   RefPtr<Uint8Array> dst_pixels =
       CopySkImageData(image_->ImageForCurrentFrame().get(), info);
   return dst_pixels.Release();
 }
 
@@ skipping 36 matching lines @@
     return ScriptPromise();
   return ImageBitmapSource::FulfillImageBitmap(
       script_state, Create(this, crop_rect, options));
 }
 
 PassRefPtr<Image> ImageBitmap::GetSourceImageForCanvas(
     SourceImageStatus* status,
     AccelerationHint,
     SnapshotReason,
     const FloatSize&) {
+  LOG(ERROR) << "HERE too ...";
   *status = kNormalSourceImageStatus;
   if (!image_)
     return nullptr;
   if (image_->IsPremultiplied())
     return image_;
   // Skia does not support drawing unpremul SkImage on SkCanvas.
   // Premultiply and return.
   sk_sp<SkImage> premul_sk_image =
       UnPremulSkImageToPremul(image_->ImageForCurrentFrame().get());
   return StaticBitmapImage::Create(premul_sk_image);
 }
 
 void ImageBitmap::AdjustDrawRects(FloatRect* src_rect,
                                   FloatRect* dst_rect) const {}
 
 FloatSize ImageBitmap::ElementSize(const FloatSize&) const {
   return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap) {}
 
 }  // namespace blink