Remove all usage of SkTransferFunctionBehavior

This enum is going away, and is always assumed to be kIgnore within Skia.

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_layout_tests_slimming_paint_v2;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I1d330478aab486864395ef36762f12f3df76c4d2
Reviewed-on: https://chromium-review.googlesource.com/1135551Reviewed-by: Florin Malita <fmalita@chromium.org>
Reviewed-by: Jeremy Roman <jbroman@chromium.org>
Reviewed-by: Eric Karl <ericrk@chromium.org>
Reviewed-by: ccameron <ccameron@chromium.org>
Reviewed-by: Oliver Chang <ochang@chromium.org>
Reviewed-by: Mike Klein <mtklein@chromium.org>
Commit-Queue: Brian Osman <brianosman@google.com>
Cr-Commit-Position: refs/heads/master@{#575614}

cc/paint/image_transfer_cache_entry.cc

@@ -36,8 +36,7 @@ sk_sp<SkImage> MakeTextureImage(GrContext* context,
     // TODO(ericrk): consider adding in the DeleteSkImageAndPreventCaching
     // optimization from GpuImageDecodeCache where we forcefully remove the
     // intermediate from Skia's cache.
-    uploaded_image = uploaded_image->makeColorSpace(
-        target_color_space, SkTransferFunctionBehavior::kIgnore);
+    uploaded_image = uploaded_image->makeColorSpace(target_color_space);
   }
 
   // Step 3: If we had a colorspace conversion, we couldn't mipmap in step 1, so
@@ -203,8 +202,7 @@ bool ServiceImageTransferCacheEntry::Deserialize(
     if (!original)
       return false;
     if (target_color_space) {
-      image_ = original->makeColorSpace(target_color_space,
-                                        SkTransferFunctionBehavior::kIgnore);
+      image_ = original->makeColorSpace(target_color_space);
       // If color space conversion is a noop, use original data.
       if (image_ == original)
         image_ = SkImage::MakeRasterCopy(pixmap);

cc/paint/paint_image.cc

@@ -228,8 +228,7 @@ bool PaintImage::DecodeFromSkImage(void* memory,
   auto image = GetSkImageForFrame(frame_index);
   DCHECK(image);
   if (color_space) {
-    image =
-        image->makeColorSpace(color_space, SkTransferFunctionBehavior::kIgnore);
+    image = image->makeColorSpace(color_space);
     if (!image)
       return false;
   }

cc/tiles/gpu_image_decode_cache.cc

@@ -303,8 +303,7 @@ sk_sp<SkImage> MakeTextureImage(viz::RasterContextProvider* context,
   // Step 2: Apply a color-space conversion if necessary.
   if (uploaded_image && target_color_space) {
     sk_sp<SkImage> pre_converted_image = uploaded_image;
-    uploaded_image = uploaded_image->makeColorSpace(
-        target_color_space, SkTransferFunctionBehavior::kIgnore);
+    uploaded_image = uploaded_image->makeColorSpace(target_color_space);
 
     if (uploaded_image != pre_converted_image)
       DeleteSkImageAndPreventCaching(context, std::move(pre_converted_image));

third_party/blink/renderer/core/html/canvas/canvas_async_blob_creator.cc

@@ -226,8 +226,7 @@ CanvasAsyncBlobCreator::CanvasAsyncBlobCreator(
   // covnert to the requested color space and pixel format.
   if (function_type_ != kHTMLCanvasConvertToBlobPromise) {
     if (skia_image->colorSpace()) {
-      image_ = image_->ConvertToColorSpace(SkColorSpace::MakeSRGB(),
-                                           SkTransferFunctionBehavior::kIgnore);
+      image_ = image_->ConvertToColorSpace(SkColorSpace::MakeSRGB());
       skia_image = image_->PaintImageForCurrentFrame().GetSkImage();
     }
 
@@ -248,8 +247,7 @@ CanvasAsyncBlobCreator::CanvasAsyncBlobCreator(
         skia_image = SkImage::MakeFromRaster(src_data_, nullptr, nullptr);
       }
       DCHECK(skia_image->colorSpace());
-      skia_image = skia_image->makeColorSpace(
-          blob_color_space, SkTransferFunctionBehavior::kIgnore);
+      skia_image = skia_image->makeColorSpace(blob_color_space);
       image_ = StaticBitmapImage::Create(skia_image);
     }
 
@@ -330,12 +328,7 @@ bool CanvasAsyncBlobCreator::EncodeImage(const double& quality) {
   std::unique_ptr<ImageDataBuffer> buffer = ImageDataBuffer::Create(src_data_);
   if (!buffer)
     return false;
-  SkTransferFunctionBehavior transfer_fn_behavior =
-      SkTransferFunctionBehavior::kIgnore;
-  if (function_type_ == kHTMLCanvasConvertToBlobPromise)
-    transfer_fn_behavior = SkTransferFunctionBehavior::kIgnore;
-  return buffer->EncodeImage("image/webp", quality, &encoded_image_,
-                             transfer_fn_behavior);
+  return buffer->EncodeImage("image/webp", quality, &encoded_image_);
 }
 
 void CanvasAsyncBlobCreator::ScheduleAsyncBlobCreation(const double& quality) {
@@ -545,7 +538,6 @@ bool CanvasAsyncBlobCreator::InitializeEncoder(double quality) {
     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;
     }
@@ -560,7 +552,6 @@ bool CanvasAsyncBlobCreator::InitializeEncoder(double quality) {
     SkPngEncoder::Options options;
     options.fFilterFlags = SkPngEncoder::FilterFlag::kSub;
     options.fZLibLevel = 3;
-    options.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
     encoder_ = ImageEncoder::Create(&encoded_image_, src_data_, options);
   }
 
@@ -655,8 +646,7 @@ bool CanvasAsyncBlobCreator::EncodeImageForConvertToBlobTest() {
   if (!buffer)
     return false;
   return buffer->EncodeImage(encode_options_.type(), encode_options_.quality(),
-                             &encoded_image_,
-                             SkTransferFunctionBehavior::kIgnore);
+                             &encoded_image_);
 }
 
 }  // namespace blink

third_party/blink/renderer/core/html/canvas/canvas_async_blob_creator_test.cc

@@ -301,8 +301,7 @@ TEST_F(CanvasAsyncBlobCreatorTest, ColorManagedConvertToBlob) {
 
           sk_sp<SkImage> ref_image = source_image->makeColorSpace(
               CanvasAsyncBlobCreator::BlobColorSpaceToSkColorSpace(
-                  blob_color_space),
-              SkTransferFunctionBehavior::kIgnore);
+                  blob_color_space));
 
           // Jpeg does not support transparent images.
           bool compare_alpha = (blob_mime_type != "image/jpeg");

third_party/blink/renderer/core/html/canvas/image_data.cc

@@ -367,8 +367,7 @@ ImageData* ImageData::Create(scoped_refptr<StaticBitmapImage> image,
     if (!f16_array)
       return nullptr;
     if (!pixmap.readPixels(image_info, f16_array->Data(),
-                           image_info.minRowBytes(), 0, 0,
-                           SkTransferFunctionBehavior::kIgnore)) {
+                           image_info.minRowBytes())) {
       NOTREACHED();
       return nullptr;
     }

third_party/blink/renderer/core/imagebitmap/image_bitmap.cc

@@ -447,20 +447,8 @@ scoped_refptr<StaticBitmapImage> ScaleImage(
 scoped_refptr<StaticBitmapImage> ApplyColorSpaceConversion(
     scoped_refptr<StaticBitmapImage>&& image,
     ImageBitmap::ParsedOptions& options) {
-  SkTransferFunctionBehavior transfer_function_behavior =
-      SkTransferFunctionBehavior::kIgnore;
-  // We normally expect to respect transfer function. However, in two scenarios
-  // we have to ignore the transfer function. First, when the source image is
-  // unpremul. Second, when the source image is drawn using a
-  // SkColorSpaceXformCanvas.
-  sk_sp<SkImage> skia_image = image->PaintImageForCurrentFrame().GetSkImage();
-  if (!skia_image->colorSpace() ||
-      skia_image->alphaType() == kUnpremul_SkAlphaType)
-    transfer_function_behavior = SkTransferFunctionBehavior::kIgnore;
-
   return image->ConvertToColorSpace(
-      options.color_params.GetSkColorSpaceForSkSurfaces(),
-      transfer_function_behavior);
+      options.color_params.GetSkColorSpaceForSkSurfaces());
 }
 
 scoped_refptr<StaticBitmapImage> MakeBlankImage(

third_party/blink/renderer/core/inspector/inspector_audits_agent.cc

@@ -55,8 +55,7 @@ bool EncodeAsImage(char* body,
 
   String mime_type = "image/";
   mime_type.append(encoding);
-  return image_to_encode->EncodeImage(mime_type, quality, output,
-                                      SkTransferFunctionBehavior::kIgnore);
+  return image_to_encode->EncodeImage(mime_type, quality, output);
 }
 
 }  // namespace

third_party/blink/renderer/core/messaging/blink_transferable_message_struct_traits.cc

@@ -26,8 +26,7 @@ scoped_refptr<blink::StaticBitmapImage> ToStaticBitmapImage(
 
   SkImageInfo info = sk_bitmap.info();
   if (!sk_bitmap.readPixels(info, array_buffer_contents.Data(),
-                            info.minRowBytes(), 0, 0,
-                            SkTransferFunctionBehavior::kIgnore))
+                            info.minRowBytes(), 0, 0))
     return nullptr;
 
   return blink::StaticBitmapImage::Create(array_buffer_contents, info);

third_party/blink/renderer/platform/graphics/decoding_image_generator.cc

@@ -160,10 +160,7 @@ bool DecodingImageGenerator::GetPixels(const SkImageInfo& dst_info,
     TRACE_EVENT0("blink", "DecodingImageGenerator::getPixels - apply xform");
     SkPixmap src(decode_info, pixels, row_bytes);
 
-    // kIgnore ensures that we perform the premultiply (if necessary) in the dst
-    // space.
-    const bool converted = src.readPixels(dst_info, pixels, row_bytes, 0, 0,
-                                          SkTransferFunctionBehavior::kIgnore);
+    const bool converted = src.readPixels(dst_info, pixels, row_bytes);
     DCHECK(converted);
   }
 

third_party/blink/renderer/platform/graphics/image_data_buffer.cc

@@ -117,28 +117,22 @@ const unsigned char* ImageDataBuffer::Pixels() const {
   return static_cast<const unsigned char*>(pixmap_.addr());
 }
 
-bool ImageDataBuffer::EncodeImage(
-    const String& mime_type,
-    const double& quality,
-    Vector<unsigned char>* encoded_image,
-    SkTransferFunctionBehavior transfer_fn_behavior) const {
-  return EncodeImageInternal(mime_type, quality, encoded_image, pixmap_,
-                             transfer_fn_behavior);
+bool ImageDataBuffer::EncodeImage(const String& mime_type,
+                                  const double& quality,
+                                  Vector<unsigned char>* encoded_image) const {
+  return EncodeImageInternal(mime_type, quality, encoded_image, pixmap_);
 }
 
-bool ImageDataBuffer::EncodeImageInternal(
-    const String& mime_type,
-    const double& quality,
-    Vector<unsigned char>* encoded_image,
-    const SkPixmap& pixmap,
-    SkTransferFunctionBehavior transfer_fn_behavior) const {
+bool ImageDataBuffer::EncodeImageInternal(const String& mime_type,
+                                          const double& quality,
+                                          Vector<unsigned char>* encoded_image,
+                                          const SkPixmap& pixmap) const {
   DCHECK(is_valid_);
 
   if (mime_type == "image/jpeg") {
     SkJpegEncoder::Options options;
     options.fQuality = ImageEncoder::ComputeJpegQuality(quality);
     options.fAlphaOption = SkJpegEncoder::AlphaOption::kBlendOnBlack;
-    options.fBlendBehavior = transfer_fn_behavior;
     if (options.fQuality == 100) {
       options.fDownsample = SkJpegEncoder::Downsample::k444;
     }
@@ -146,8 +140,7 @@ bool ImageDataBuffer::EncodeImageInternal(
   }
 
   if (mime_type == "image/webp") {
-    SkWebpEncoder::Options options =
-        ImageEncoder::ComputeWebpOptions(quality, transfer_fn_behavior);
+    SkWebpEncoder::Options options = ImageEncoder::ComputeWebpOptions(quality);
     return ImageEncoder::Encode(encoded_image, pixmap, options);
   }
 
@@ -155,7 +148,6 @@ bool ImageDataBuffer::EncodeImageInternal(
   SkPngEncoder::Options options;
   options.fFilterFlags = SkPngEncoder::FilterFlag::kSub;
   options.fZLibLevel = 3;
-  options.fUnpremulBehavior = transfer_fn_behavior;
   return ImageEncoder::Encode(encoded_image, pixmap, options);
 }
 
@@ -171,16 +163,14 @@ String ImageDataBuffer::ToDataURL(const String& mime_type,
   if (pixmap.colorSpace()) {
     if (!pixmap.colorSpace()->isSRGB()) {
       skia_image = SkImage::MakeFromRaster(pixmap, nullptr, nullptr);
-      skia_image = skia_image->makeColorSpace(
-          SkColorSpace::MakeSRGB(), SkTransferFunctionBehavior::kIgnore);
+      skia_image = skia_image->makeColorSpace(SkColorSpace::MakeSRGB());
       skia_image->peekPixels(&pixmap);
     }
     pixmap.setColorSpace(nullptr);
   }
 
   Vector<unsigned char> result;
-  if (!EncodeImageInternal(mime_type, quality, &result, pixmap,
-                           SkTransferFunctionBehavior::kIgnore))
+  if (!EncodeImageInternal(mime_type, quality, &result, pixmap))
     return "data:,";
 
   return "data:" + mime_type + ";base64," + Base64Encode(result);

third_party/blink/renderer/platform/graphics/image_data_buffer.h

@@ -50,8 +50,7 @@ class PLATFORM_EXPORT ImageDataBuffer {
   String ToDataURL(const String& mime_type, const double& quality) const;
   bool EncodeImage(const String& mime_type,
                    const double& quality,
-                   Vector<unsigned char>* encoded_image,
-                   SkTransferFunctionBehavior transfer_fn_behavior) const;
+                   Vector<unsigned char>* encoded_image) const;
 
   const unsigned char* Pixels() const;
   const IntSize& size() const { return size_; }
@@ -67,12 +66,10 @@ class PLATFORM_EXPORT ImageDataBuffer {
 
   bool IsValid() { return is_valid_; }  // Only used by Create()
 
-  bool EncodeImageInternal(
-      const String& mime_type,
-      const double& quality,
-      Vector<unsigned char>* encoded_image,
-      const SkPixmap& pixmap,
-      SkTransferFunctionBehavior transfer_fn_behavior) const;
+  bool EncodeImageInternal(const String& mime_type,
+                           const double& quality,
+                           Vector<unsigned char>* encoded_image,
+                           const SkPixmap& pixmap) const;
 
   sk_sp<SkImage> retained_image_;
   SkPixmap pixmap_;

third_party/blink/renderer/platform/graphics/logging_canvas.cc

@@ -273,7 +273,6 @@ std::unique_ptr<JSONObject> ObjectForBitmapData(const SkBitmap& bitmap) {
   SkPngEncoder::Options options;
   options.fFilterFlags = SkPngEncoder::FilterFlag::kSub;
   options.fZLibLevel = 3;
-  options.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
   if (!ImageEncoder::Encode(&output, src, options)) {
     return nullptr;
   }

third_party/blink/renderer/platform/graphics/picture_snapshot.cc

@@ -123,7 +123,6 @@ Vector<char> PictureSnapshot::Replay(unsigned from_step,
   SkPngEncoder::Options options;
   options.fFilterFlags = SkPngEncoder::FilterFlag::kSub;
   options.fZLibLevel = 3;
-  options.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
   if (!ImageEncoder::Encode(
           reinterpret_cast<Vector<unsigned char>*>(&encoded_image), src,
           options)) {

third_party/blink/renderer/platform/graphics/static_bitmap_image.cc

@@ -79,8 +79,7 @@ void StaticBitmapImage::DrawHelper(cc::PaintCanvas* canvas,
 }
 
 scoped_refptr<StaticBitmapImage> StaticBitmapImage::ConvertToColorSpace(
-    sk_sp<SkColorSpace> target,
-    SkTransferFunctionBehavior transfer_function_behavior) {
+    sk_sp<SkColorSpace> target) {
   sk_sp<SkImage> skia_image = PaintImageForCurrentFrame().GetSkImage();
   sk_sp<SkColorSpace> src_color_space = skia_image->refColorSpace();
   if (!src_color_space.get())
@@ -92,7 +91,7 @@ scoped_refptr<StaticBitmapImage> StaticBitmapImage::ConvertToColorSpace(
     return this;
 
   sk_sp<SkImage> converted_skia_image =
-      skia_image->makeColorSpace(dst_color_space, transfer_function_behavior);
+      skia_image->makeColorSpace(dst_color_space);
   DCHECK(converted_skia_image.get());
   DCHECK(skia_image.get() != converted_skia_image.get());
 

third_party/blink/renderer/platform/graphics/static_bitmap_image.h

@@ -113,9 +113,7 @@ class PLATFORM_EXPORT StaticBitmapImage : public Image {
   // Methods have exactly the same implementation for all sub-classes
   bool OriginClean() const { return is_origin_clean_; }
   void SetOriginClean(bool flag) { is_origin_clean_ = flag; }
-  scoped_refptr<StaticBitmapImage> ConvertToColorSpace(
-      sk_sp<SkColorSpace>,
-      SkTransferFunctionBehavior);
+  scoped_refptr<StaticBitmapImage> ConvertToColorSpace(sk_sp<SkColorSpace>);
 
   static bool ConvertToArrayBufferContents(
       scoped_refptr<StaticBitmapImage> src_image,

third_party/blink/renderer/platform/image-encoders/image_encoder.cc

@@ -87,11 +87,8 @@ int ImageEncoder::ComputeJpegQuality(double quality) {
   return compression_quality;
 }
 
-SkWebpEncoder::Options ImageEncoder::ComputeWebpOptions(
-    double quality,
-    SkTransferFunctionBehavior unpremulBehavior) {
+SkWebpEncoder::Options ImageEncoder::ComputeWebpOptions(double quality) {
   SkWebpEncoder::Options options;
-  options.fUnpremulBehavior = unpremulBehavior;
 
   if (quality == 1.0) {
     // Choose a lossless encode.  When performing a lossless encode, higher

third_party/blink/renderer/platform/image-encoders/image_encoder.h

@@ -85,9 +85,7 @@ class PLATFORM_EXPORT ImageEncoder {
    *  is out of range, this will perform a lossy encode with the default
    *  value (80).
    */
-  static SkWebpEncoder::Options ComputeWebpOptions(
-      double quality,
-      SkTransferFunctionBehavior unpremulBehavior);
+  static SkWebpEncoder::Options ComputeWebpOptions(double quality);
 
  private:
   ImageEncoder(Vector<unsigned char>* dst) : dst_(dst) {}