Plumb CanvasColorParams to canvas image classes

third_party/WebKit/Source/platform/graphics/ImageBuffer.cpp

 /*
  * Copyright (c) 2008, Google Inc. All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
@@ skipping 62 matching lines @@
     std::unique_ptr<ImageBufferSurface> surface) {
   if (!surface->IsValid())
     return nullptr;
   return WTF::WrapUnique(new ImageBuffer(std::move(surface)));
 }
 
 std::unique_ptr<ImageBuffer> ImageBuffer::Create(
     const IntSize& size,
     OpacityMode opacity_mode,
     ImageInitializationMode initialization_mode,
-    sk_sp<SkColorSpace> color_space) {
-  SkColorType color_type = kN32_SkColorType;
-  if (color_space && SkColorSpace::Equals(color_space.get(),
-                                          SkColorSpace::MakeSRGBLinear().get()))
-    color_type = kRGBA_F16_SkColorType;
-
+    const CanvasColorParams& color_params) {
   std::unique_ptr<ImageBufferSurface> surface(
       WTF::WrapUnique(new UnacceleratedImageBufferSurface(
-          size, opacity_mode, initialization_mode, std::move(color_space),
-          color_type)));
+          size, opacity_mode, initialization_mode, color_params)));
 
   if (!surface->IsValid())
     return nullptr;
   return WTF::WrapUnique(new ImageBuffer(std::move(surface)));
 }
 
 ImageBuffer::ImageBuffer(std::unique_ptr<ImageBufferSurface> surface)
     : weak_ptr_factory_(this),
       snapshot_state_(kInitialSnapshotState),
       surface_(std::move(surface)),
@@ skipping 244 matching lines @@
 
 void ImageBuffer::FlushGpu(FlushReason reason) {
   if (surface_->Canvas()) {
     surface_->FlushGpu(reason);
   }
 }
 
 bool ImageBuffer::GetImageData(Multiply multiplied,
                                const IntRect& rect,
                                WTF::ArrayBufferContents& contents) const {
-  uint8_t bytes_per_pixel = 4;
-  if (surface_->ColorSpace())
-    bytes_per_pixel = SkColorTypeBytesPerPixel(surface_->ColorType());
+  uint8_t bytes_per_pixel = surface_->color_params().BytesPerPixel();
   CheckedNumeric<int> data_size = bytes_per_pixel;
   data_size *= rect.Width();
   data_size *= rect.Height();
   if (!data_size.IsValid())
     return false;
 
   if (!IsSurfaceValid()) {
     size_t alloc_size_in_bytes = rect.Width() * rect.Height() * bytes_per_pixel;
     auto data = WTF::ArrayBufferContents::CreateDataHandle(
         alloc_size_in_bytes, WTF::ArrayBufferContents::kZeroInitialize);
@@ skipping 22 matching lines @@
       may_have_stray_area ? WTF::ArrayBufferContents::kZeroInitialize
                           : WTF::ArrayBufferContents::kDontInitialize;
   auto data = WTF::ArrayBufferContents::CreateDataHandle(alloc_size_in_bytes,
                                                          initialization_policy);
   if (!data)
     return false;
   WTF::ArrayBufferContents result(std::move(data), alloc_size_in_bytes,
                                   WTF::ArrayBufferContents::kNotShared);
 
   // Skia does not support unpremultiplied read with an F16 to 8888 conversion
-  bool use_f16_workaround = surface_->ColorType() == kRGBA_F16_SkColorType;
+  bool use_f16_workaround =
+      surface_->color_params().GetSkColorType() == kRGBA_F16_SkColorType;
 
   SkAlphaType alpha_type = (multiplied == kPremultiplied || use_f16_workaround)
                                ? kPremul_SkAlphaType
                                : kUnpremul_SkAlphaType;
   // The workaround path use a canvas draw under the hood, which can only
   // use N32 at this time.
   SkColorType color_type =
       use_f16_workaround ? kN32_SkColorType : kRGBA_8888_SkColorType;
 
   // Only use sRGB when the surface has a color space.  Converting untagged
   // pixels to a particular color space is not well-defined in Skia.
-  sk_sp<SkColorSpace> color_space = nullptr;
-  if (surface_->ColorSpace()) {
-    color_space = SkColorSpace::MakeSRGB();
-  }
+  sk_sp<SkColorSpace> color_space =
+      surface_->color_params().GetSkColorSpaceForSkSurfaces();
 
   SkImageInfo info = SkImageInfo::Make(rect.Width(), rect.Height(), color_type,
                                        alpha_type, std::move(color_space));
 
   snapshot->readPixels(info, result.Data(), bytes_per_pixel * rect.Width(),
                        rect.X(), rect.Y());
   gpu_readback_invoked_in_current_frame_ = true;
 
   if (use_f16_workaround) {
     uint32_t* pixel = (uint32_t*)result.Data();
@@ skipping 20 matching lines @@
   return true;
 }
 
 void ImageBuffer::PutByteArray(Multiply multiplied,
                                const unsigned char* source,
                                const IntSize& source_size,
                                const IntRect& source_rect,
                                const IntPoint& dest_point) {
   if (!IsSurfaceValid())
     return;
-  uint8_t bytes_per_pixel = 4;
-  if (surface_->ColorSpace())
-    bytes_per_pixel = SkColorTypeBytesPerPixel(surface_->ColorType());
+  uint8_t bytes_per_pixel = surface_->color_params().BytesPerPixel();
 
   DCHECK_GT(source_rect.Width(), 0);
   DCHECK_GT(source_rect.Height(), 0);
 
   int origin_x = source_rect.X();
   int dest_x = dest_point.X() + source_rect.X();
   DCHECK_GE(dest_x, 0);
   DCHECK_LT(dest_x, surface_->size().Width());
   DCHECK_GE(origin_x, 0);
   DCHECK_LT(origin_x, source_rect.MaxX());
@@ skipping 16 matching lines @@
     // Skia.  There is some discussion about whether it should be
     // defined in skbug.com/6157.  For now, we can get the desired
     // behavior (memcpy) by pretending the write is opaque.
     alpha_type = kOpaque_SkAlphaType;
   } else {
     alpha_type = (multiplied == kPremultiplied) ? kPremul_SkAlphaType
                                                 : kUnpremul_SkAlphaType;
   }
 
   SkImageInfo info;
-  if (surface_->ColorSpace()) {
-    info = SkImageInfo::Make(source_rect.Width(), source_rect.Height(),
-                             surface_->ColorType(), alpha_type,
-                             surface_->ColorSpace());
+  if (surface_->color_params().GetSkColorSpaceForSkSurfaces()) {
+    info = SkImageInfo::Make(
+        source_rect.Width(), source_rect.Height(),
+        surface_->color_params().GetSkColorType(), alpha_type,
+        surface_->color_params().GetSkColorSpaceForSkSurfaces());
   } else {
     info = SkImageInfo::Make(source_rect.Width(), source_rect.Height(),
                              kRGBA_8888_SkColorType, alpha_type,
                              SkColorSpace::MakeSRGB());
   }
   surface_->WritePixels(info, src_addr, src_bytes_per_row, dest_x, dest_y);
 }
 
 void ImageBuffer::UpdateGPUMemoryUsage() const {
   if (this->IsAccelerated()) {
     // If image buffer is accelerated, we should keep track of GPU memory usage.
     int gpu_buffer_count = 2;
     CheckedNumeric<intptr_t> checked_gpu_usage =
-        SkColorTypeBytesPerPixel(surface_->ColorType()) * gpu_buffer_count;
+        surface_->color_params().BytesPerPixel() * gpu_buffer_count;
     checked_gpu_usage *= this->size().Width();
     checked_gpu_usage *= this->size().Height();
     intptr_t gpu_memory_usage =
         checked_gpu_usage.ValueOrDefault(std::numeric_limits<intptr_t>::max());
 
     if (!gpu_memory_usage_)  // was not accelerated before
       global_accelerated_image_buffer_count_++;
 
     global_gpu_memory_usage_ += (gpu_memory_usage - gpu_memory_usage_);
     gpu_memory_usage_ = gpu_memory_usage;
@@ skipping 11 matching lines @@
 }
 
 namespace {
 
 class UnacceleratedSurfaceFactory
     : public RecordingImageBufferFallbackSurfaceFactory {
  public:
   virtual std::unique_ptr<ImageBufferSurface> CreateSurface(
       const IntSize& size,
       OpacityMode opacity_mode,
-      sk_sp<SkColorSpace> color_space,
-      SkColorType color_type) {
+      const CanvasColorParams& color_params) {
     return WTF::WrapUnique(new UnacceleratedImageBufferSurface(
-        size, opacity_mode, kInitializeImagePixels, std::move(color_space),
-        color_type));
+        size, opacity_mode, kInitializeImagePixels, color_params));
   }
 
   virtual ~UnacceleratedSurfaceFactory() {}
 };
 
 }  // namespace
 
 void ImageBuffer::DisableAcceleration() {
   if (!IsAccelerated())
     return;
 
   // Create and configure a recording (unaccelerated) surface.
   std::unique_ptr<RecordingImageBufferFallbackSurfaceFactory> surface_factory =
       WTF::MakeUnique<UnacceleratedSurfaceFactory>();
   std::unique_ptr<ImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           surface_->size(), std::move(surface_factory),
-          surface_->GetOpacityMode(), surface_->ColorSpace(),
-          surface_->ColorType()));
+          surface_->GetOpacityMode(), surface_->color_params()));
   SetSurface(std::move(surface));
 }
 
 void ImageBuffer::SetSurface(std::unique_ptr<ImageBufferSurface> surface) {
   sk_sp<SkImage> image =
       surface_->NewImageSnapshot(kPreferNoAcceleration, kSnapshotReasonPaint);
 
   // image can be null if alloaction failed in which case we should just
   // abort the surface switch to reatain the old surface which is still
   // functional.
@@ skipping 45 matching lines @@
   DCHECK(MIMETypeRegistry::IsSupportedImageMIMETypeForEncoding(mime_type));
 
   Vector<unsigned char> result;
   if (!EncodeImage(mime_type, quality, &result))
     return "data:,";
 
   return "data:" + mime_type + ";base64," + Base64Encode(result);
 }
 
 }  // namespace blink