Replace nearly all kRespect with kIgnore

- Encoders and decoders always assume kIgnore.
- They are less opinionated about F16 and color space,
  we just trust the color space that's passed in, and
  put that directly in the image (no sRGB encoding).
- SkBitmap and SkPixmap read/write pixels functions were
  defaulting to kResepct, those are now always kIgnore.
- Many other bits of plumbing are simplified, and I
  added a default of kIgnore to SkImage::makeColorSpace,
  so we can phase out that argument entirely.
- Still need to add defaults to other public APIs that
  take SkTransferFunctionBehavior.

- This makes gold think that we've dramatically changed
  the contents of all F16 images, but that's because
  it doesn't understand the (now linear) color space
  that's embedded. Once we triage them all once, they
  will work fine (and they'll look perfect in the browser).

Bug: skia:
Change-Id: I62fa090f96cae1b67d181ce14bd91f34ff2ed747
Reviewed-on: https://skia-review.googlesource.com/140570
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Klein <mtklein@google.com>

44 files changed, 118 insertions, 320 deletions

diff --git a/bench/EncoderBench.cpp b/bench/EncoderBench.cpp
index c60061b610..0e98b73a0f 100644
--- a/bench/EncoderBench.cpp
+++ b/bench/EncoderBench.cpp
@@ -56,7 +56,6 @@ static bool encode_webp_lossy(SkWStream* dst, const SkPixmap& src) {
     SkWebpEncoder::Options opts;
     opts.fCompression = SkWebpEncoder::Compression::kLossy;
     opts.fQuality = 90;
-    opts.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
     return SkWebpEncoder::Encode(dst, src, opts);
 }
 
@@ -64,7 +63,6 @@ static bool encode_webp_lossless(SkWStream* dst, const SkPixmap& src) {
     SkWebpEncoder::Options opts;
     opts.fCompression = SkWebpEncoder::Compression::kLossless;
     opts.fQuality = 90;
-    opts.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
     return SkWebpEncoder::Encode(dst, src, opts);
 }
 
@@ -74,7 +72,6 @@ static bool encode_png(SkWStream* dst,
                        int zlibLevel) {
     SkPngEncoder::Options opts;
     opts.fFilterFlags = filters;
-    opts.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
     opts.fZLibLevel = zlibLevel;
     return SkPngEncoder::Encode(dst, src, opts);
 }
diff --git a/dm/DM.cpp b/dm/DM.cpp
index 5b3642ac84..e66621d7c2 100644
--- a/dm/DM.cpp
+++ b/dm/DM.cpp
@@ -1042,7 +1042,6 @@ static bool dump_png(SkBitmap bitmap, const char* path, const char* md5) {
     options.fComments         = SkDataTable::MakeCopyArrays((const void**)comments, lengths, 4);
     options.fFilterFlags      = SkPngEncoder::FilterFlag::kNone;
     options.fZLibLevel        = 1;
-    options.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
     return SkPngEncoder::Encode(&dst, pm, options);
 }
 
diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp
index 25b87b376e..d524b1bea2 100644
--- a/dm/DMSrcSink.cpp
+++ b/dm/DMSrcSink.cpp
@@ -473,8 +473,6 @@ Error CodecSrc::draw(SkCanvas* canvas) const {
     SkAutoMalloc pixels(safeSize);
 
     SkCodec::Options options;
-    options.fPremulBehavior = canvas->imageInfo().colorSpace() ?
-            SkTransferFunctionBehavior::kRespect : SkTransferFunctionBehavior::kIgnore;
     if (kCodecZeroInit_Mode == fMode) {
         memset(pixels.get(), 0, size.height() * rowBytes);
         options.fZeroInitialized = SkCodec::kYes_ZeroInitialized;
@@ -1397,8 +1395,6 @@ static bool encode_png_base64(const SkBitmap& bitmap, SkString* dst) {
     SkPngEncoder::Options options;
     options.fFilterFlags = SkPngEncoder::FilterFlag::kAll;
     options.fZLibLevel = 9;
-    options.fUnpremulBehavior = pm.colorSpace() ? SkTransferFunctionBehavior::kRespect
-                                                : SkTransferFunctionBehavior::kIgnore;
 
     SkDynamicMemoryWStream wStream;
     if (!SkPngEncoder::Encode(&wStream, pm, options)) {
diff --git a/gm/encode-alpha-jpeg.cpp b/gm/encode-alpha-jpeg.cpp
index 6d26d7a85c..9751fbbc16 100644
--- a/gm/encode-alpha-jpeg.cpp
+++ b/gm/encode-alpha-jpeg.cpp
@@ -21,11 +21,10 @@ static inline void read_into_pixmap(SkPixmap* dst, SkImageInfo dstInfo, void* ds
 }
 
 static inline sk_sp<SkImage> encode_pixmap_and_make_image(const SkPixmap& src,
-        SkJpegEncoder::AlphaOption alphaOption, SkTransferFunctionBehavior blendBehavior) {
+        SkJpegEncoder::AlphaOption alphaOption) {
     SkDynamicMemoryWStream dst;
     SkJpegEncoder::Options options;
     options.fAlphaOption = alphaOption;
-    options.fBlendBehavior = blendBehavior;
     SkJpegEncoder::Encode(&dst, src, options);
     return SkImage::MakeFromEncoded(dst.detachAsData());
 }
@@ -53,23 +52,17 @@ protected:
                 canvas->imageInfo().colorSpace() ? SkColorSpace::MakeSRGB() : nullptr);
         read_into_pixmap(&src, info, fStorage.get(), srcImg);
 
-        SkTransferFunctionBehavior behavior = canvas->imageInfo().colorSpace() ?
-                SkTransferFunctionBehavior::kRespect : SkTransferFunctionBehavior::kIgnore;
-
         // Encode 8888 premul.
-        sk_sp<SkImage> img0 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kIgnore,
-                behavior);
-        sk_sp<SkImage> img1 = encode_pixmap_and_make_image(src,
-                SkJpegEncoder::AlphaOption::kBlendOnBlack, behavior);
+        auto img0 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kIgnore);
+        auto img1 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kBlendOnBlack);
         canvas->drawImage(img0, 0.0f, 0.0f);
         canvas->drawImage(img1, 0.0f, 100.0f);
 
         // Encode 8888 unpremul
         info = info.makeAlphaType(kUnpremul_SkAlphaType);
         read_into_pixmap(&src, info, fStorage.get(), srcImg);
-        img0 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kIgnore, behavior);
-        img1 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kBlendOnBlack,
-                behavior);
+        img0 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kIgnore);
+        img1 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kBlendOnBlack);
         canvas->drawImage(img0, 100.0f, 0.0f);
         canvas->drawImage(img1, 100.0f, 100.0f);
 
@@ -78,18 +71,16 @@ protected:
             info = SkImageInfo::Make(srcImg->width(), srcImg->height(), kRGBA_F16_SkColorType,
                     kPremul_SkAlphaType, SkColorSpace::MakeSRGBLinear());
             read_into_pixmap(&src, info, fStorage.get(), srcImg);
-            img0 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kIgnore, behavior);
-            img1 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kBlendOnBlack,
-                    behavior);
+            img0 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kIgnore);
+            img1 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kBlendOnBlack);
             canvas->drawImage(img0, 200.0f, 0.0f);
             canvas->drawImage(img1, 200.0f, 100.0f);
 
             // Encode F16 unpremul
             info = info.makeAlphaType(kUnpremul_SkAlphaType);
             read_into_pixmap(&src, info, fStorage.get(), srcImg);
-            img0 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kIgnore, behavior);
-            img1 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kBlendOnBlack,
-                    behavior);
+            img0 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kIgnore);
+            img1 = encode_pixmap_and_make_image(src, SkJpegEncoder::AlphaOption::kBlendOnBlack);
             canvas->drawImage(img0, 300.0f, 0.0f);
             canvas->drawImage(img1, 300.0f, 100.0f);
         }
diff --git a/gm/encode-platform.cpp b/gm/encode-platform.cpp
index a9eaae6128..9f94597fa7 100644
--- a/gm/encode-platform.cpp
+++ b/gm/encode-platform.cpp
@@ -72,9 +72,7 @@ static sk_sp<SkData> encode_data(SkEncodedImageFormat type, const SkBitmap& bitm
     #else
         switch (type) {
             case SkEncodedImageFormat::kPNG: {
-                SkPngEncoder::Options options;
-                options.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
-                bool success = SkPngEncoder::Encode(&buf, src, options);
+                bool success = SkPngEncoder::Encode(&buf, src, SkPngEncoder::Options());
                 return success ? buf.detachAsData() : nullptr;
             }
             case SkEncodedImageFormat::kJPEG: {
@@ -82,9 +80,7 @@ static sk_sp<SkData> encode_data(SkEncodedImageFormat type, const SkBitmap& bitm
                 return success ? buf.detachAsData() : nullptr;
             }
             case SkEncodedImageFormat::kWEBP: {
-                SkWebpEncoder::Options options;
-                options.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
-                bool success = SkWebpEncoder::Encode(&buf, src, options);
+                bool success = SkWebpEncoder::Encode(&buf, src, SkWebpEncoder::Options());
                 return success ? buf.detachAsData() : nullptr;
             }
             default:
diff --git a/gm/encode-srgb.cpp b/gm/encode-srgb.cpp
index 3b9526b3c9..699364291d 100644
--- a/gm/encode-srgb.cpp
+++ b/gm/encode-srgb.cpp
@@ -70,19 +70,12 @@ static sk_sp<SkData> encode_data(const SkBitmap& bitmap, SkEncodedImageFormat fo
     }
     SkDynamicMemoryWStream buf;
 
-    SkPngEncoder::Options pngOptions;
-    SkWebpEncoder::Options webpOptions;
-    SkTransferFunctionBehavior behavior = bitmap.colorSpace()
-            ? SkTransferFunctionBehavior::kRespect : SkTransferFunctionBehavior::kIgnore;
-    pngOptions.fUnpremulBehavior = behavior;
-    webpOptions.fUnpremulBehavior = behavior;
-
     switch (format) {
         case SkEncodedImageFormat::kPNG:
-            SkAssertResult(SkPngEncoder::Encode(&buf, src, pngOptions));
+            SkAssertResult(SkPngEncoder::Encode(&buf, src, SkPngEncoder::Options()));
             break;
         case SkEncodedImageFormat::kWEBP:
-            SkAssertResult(SkWebpEncoder::Encode(&buf, src, webpOptions));
+            SkAssertResult(SkWebpEncoder::Encode(&buf, src, SkWebpEncoder::Options()));
             break;
         case SkEncodedImageFormat::kJPEG:
             SkAssertResult(SkJpegEncoder::Encode(&buf, src, SkJpegEncoder::Options()));
diff --git a/gm/makecolorspace.cpp b/gm/makecolorspace.cpp
index cd957c3281..ec04b74180 100644
--- a/gm/makecolorspace.cpp
+++ b/gm/makecolorspace.cpp
@@ -11,22 +11,19 @@
 #include "SkImage.h"
 #include "SkImagePriv.h"
 
-sk_sp<SkImage> make_raster_image(const char* path, SkTransferFunctionBehavior behavior) {
+sk_sp<SkImage> make_raster_image(const char* path) {
     sk_sp<SkData> resourceData = GetResourceAsData(path);
     std::unique_ptr<SkCodec> codec = SkCodec::MakeFromData(resourceData);
 
     SkBitmap bitmap;
     bitmap.allocPixels(codec->getInfo());
 
-    SkCodec::Options opts;
-    opts.fPremulBehavior = behavior;
-    codec->getPixels(codec->getInfo(), bitmap.getPixels(), bitmap.rowBytes(), &opts);
+    codec->getPixels(codec->getInfo(), bitmap.getPixels(), bitmap.rowBytes());
     return SkImage::MakeFromBitmap(bitmap);
 }
 
-sk_sp<SkImage> make_color_space(sk_sp<SkImage> orig, sk_sp<SkColorSpace> colorSpace,
-                                SkTransferFunctionBehavior behavior) {
-    sk_sp<SkImage> xform = orig->makeColorSpace(colorSpace, behavior);
+sk_sp<SkImage> make_color_space(sk_sp<SkImage> orig, sk_sp<SkColorSpace> colorSpace) {
+    sk_sp<SkImage> xform = orig->makeColorSpace(colorSpace);
 
     // Assign an sRGB color space on the xformed image, so we can see the effects of the xform
     // when we draw.
@@ -51,9 +48,6 @@ protected:
     }
 
     void onDraw(SkCanvas* canvas) override {
-        SkTransferFunctionBehavior behavior = canvas->imageInfo().colorSpace() ?
-                SkTransferFunctionBehavior::kRespect : SkTransferFunctionBehavior::kIgnore;
-
         sk_sp<SkColorSpace> wideGamut = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
                                                               SkColorSpace::kAdobeRGB_Gamut);
         sk_sp<SkColorSpace> wideGamutLinear = wideGamut->makeLinearGamma();
@@ -62,22 +56,22 @@ protected:
         sk_sp<SkImage> opaqueImage = GetResourceAsImage("images/mandrill_128.png");
         sk_sp<SkImage> premulImage = GetResourceAsImage("images/color_wheel.png");
         canvas->drawImage(opaqueImage, 0.0f, 0.0f);
-        canvas->drawImage(make_color_space(opaqueImage, wideGamut, behavior), 128.0f, 0.0f);
-        canvas->drawImage(make_color_space(opaqueImage, wideGamutLinear, behavior), 256.0f, 0.0f);
+        canvas->drawImage(make_color_space(opaqueImage, wideGamut), 128.0f, 0.0f);
+        canvas->drawImage(make_color_space(opaqueImage, wideGamutLinear), 256.0f, 0.0f);
         canvas->drawImage(premulImage, 0.0f, 128.0f);
-        canvas->drawImage(make_color_space(premulImage, wideGamut, behavior), 128.0f, 128.0f);
-        canvas->drawImage(make_color_space(premulImage, wideGamutLinear, behavior), 256.0f, 128.0f);
+        canvas->drawImage(make_color_space(premulImage, wideGamut), 128.0f, 128.0f);
+        canvas->drawImage(make_color_space(premulImage, wideGamutLinear), 256.0f, 128.0f);
         canvas->translate(0.0f, 256.0f);
 
         // Raster images
-        opaqueImage = make_raster_image("images/mandrill_128.png", behavior);
-        premulImage = make_raster_image("images/color_wheel.png", behavior);
+        opaqueImage = make_raster_image("images/mandrill_128.png");
+        premulImage = make_raster_image("images/color_wheel.png");
         canvas->drawImage(opaqueImage, 0.0f, 0.0f);
-        canvas->drawImage(make_color_space(opaqueImage, wideGamut, behavior), 128.0f, 0.0f);
-        canvas->drawImage(make_color_space(opaqueImage, wideGamutLinear, behavior), 256.0f, 0.0f);
+        canvas->drawImage(make_color_space(opaqueImage, wideGamut), 128.0f, 0.0f);
+        canvas->drawImage(make_color_space(opaqueImage, wideGamutLinear), 256.0f, 0.0f);
         canvas->drawImage(premulImage, 0.0f, 128.0f);
-        canvas->drawImage(make_color_space(premulImage, wideGamut, behavior), 128.0f, 128.0f);
-        canvas->drawImage(make_color_space(premulImage, wideGamutLinear, behavior), 256.0f, 128.0f);
+        canvas->drawImage(make_color_space(premulImage, wideGamut), 128.0f, 128.0f);
+        canvas->drawImage(make_color_space(premulImage, wideGamutLinear), 256.0f, 128.0f);
     }
 
 private:
diff --git a/include/codec/SkCodec.h b/include/codec/SkCodec.h
index ae7286d576..c156efb052 100644
--- a/include/codec/SkCodec.h
+++ b/include/codec/SkCodec.h
@@ -252,7 +252,7 @@ public:
             , fSubset(nullptr)
             , fFrameIndex(0)
             , fPriorFrame(kNone)
-            , fPremulBehavior(SkTransferFunctionBehavior::kRespect)
+            , fPremulBehavior(SkTransferFunctionBehavior::kIgnore)
         {}
 
         ZeroInitialized            fZeroInitialized;
@@ -803,8 +803,7 @@ protected:
 
     virtual int onOutputScanline(int inputScanline) const;
 
-    bool initializeColorXform(const SkImageInfo& dstInfo, SkEncodedInfo::Alpha,
-                              SkTransferFunctionBehavior premulBehavior);
+    bool initializeColorXform(const SkImageInfo& dstInfo, SkEncodedInfo::Alpha);
     // Some classes never need a colorXform e.g.
     // - ICO uses its embedded codec's colorXform
     // - WBMP is just Black/White
diff --git a/include/core/SkBitmap.h b/include/core/SkBitmap.h
index 758881aae3..bc29151a24 100644
--- a/include/core/SkBitmap.h
+++ b/include/core/SkBitmap.h
@@ -992,7 +992,7 @@ public:
     bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
                     int srcX, int srcY) const {
         return this->readPixels(dstInfo, dstPixels, dstRowBytes, srcX, srcY,
-                SkTransferFunctionBehavior::kRespect);
+                SkTransferFunctionBehavior::kIgnore);
     }
 
     /** Copies a SkRect of pixels from SkBitmap to dst. Copy starts at (srcX, srcY), and
@@ -1074,7 +1074,7 @@ public:
         @return      true if src pixels are copied to SkBitmap
     */
     bool writePixels(const SkPixmap& src, int dstX, int dstY) {
-        return this->writePixels(src, dstX, dstY, SkTransferFunctionBehavior::kRespect);
+        return this->writePixels(src, dstX, dstY, SkTransferFunctionBehavior::kIgnore);
     }
 
     /** Copies a SkRect of pixels from src. Copy starts at (0, 0), and does not exceed
diff --git a/include/core/SkImage.h b/include/core/SkImage.h
index 8957d11b61..f04dd45c78 100644
--- a/include/core/SkImage.h
+++ b/include/core/SkImage.h
@@ -877,8 +877,9 @@ public:
                                SkTransferFunctionBehavior::kIgnore
         @return                created SkImage in target SkColorSpace
     */
-    sk_sp<SkImage> makeColorSpace(sk_sp<SkColorSpace> target,
-                                  SkTransferFunctionBehavior premulBehavior) const;
+    sk_sp<SkImage> makeColorSpace(
+            sk_sp<SkColorSpace> target,
+            SkTransferFunctionBehavior premulBehavior = SkTransferFunctionBehavior::kIgnore) const;
 
 private:
     SkImage(int width, int height, uint32_t uniqueID);
diff --git a/include/core/SkPixmap.h b/include/core/SkPixmap.h
index 5e417af2ed..d3e0097e70 100644
--- a/include/core/SkPixmap.h
+++ b/include/core/SkPixmap.h
@@ -616,7 +616,7 @@ public:
     bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, int srcX,
                     int srcY) const {
         return this->readPixels(dstInfo, dstPixels, dstRowBytes, srcX, srcY,
-                                SkTransferFunctionBehavior::kRespect);
+                                SkTransferFunctionBehavior::kIgnore);
     }
 
     /** Copies a SkRect of pixels to dst. Copy starts at (srcX, srcY), and does not
diff --git a/include/encode/SkJpegEncoder.h b/include/encode/SkJpegEncoder.h
index fd7c204161..ad3ccad21a 100644
--- a/include/encode/SkJpegEncoder.h
+++ b/include/encode/SkJpegEncoder.h
@@ -61,7 +61,7 @@ public:
          *  In the second case, the encoder supports linear or legacy blending.
          */
         AlphaOption fAlphaOption = AlphaOption::kIgnore;
-        SkTransferFunctionBehavior fBlendBehavior = SkTransferFunctionBehavior::kRespect;
+        SkTransferFunctionBehavior fBlendBehavior = SkTransferFunctionBehavior::kIgnore;
     };
 
     /**
diff --git a/include/encode/SkPngEncoder.h b/include/encode/SkPngEncoder.h
index 39e407e075..035da42fe7 100644
--- a/include/encode/SkPngEncoder.h
+++ b/include/encode/SkPngEncoder.h
@@ -58,7 +58,7 @@ public:
          *  The encoder can convert to linear before unpremultiplying or ignore the transfer
          *  function and unpremultiply the input as is.
          */
-        SkTransferFunctionBehavior fUnpremulBehavior = SkTransferFunctionBehavior::kRespect;
+        SkTransferFunctionBehavior fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
 
         /**
          *  Represents comments in the tEXt ancillary chunk of the png.
diff --git a/include/encode/SkWebpEncoder.h b/include/encode/SkWebpEncoder.h
index f671be379c..f7dca61278 100644
--- a/include/encode/SkWebpEncoder.h
+++ b/include/encode/SkWebpEncoder.h
@@ -40,7 +40,7 @@ namespace SkWebpEncoder {
          *  The encoder can convert to linear before unpremultiplying or ignore the transfer
          *  function and unpremultiply the input as is.
          */
-        SkTransferFunctionBehavior fUnpremulBehavior = SkTransferFunctionBehavior::kRespect;
+        SkTransferFunctionBehavior fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
     };
 
     /**
diff --git a/src/codec/SkCodec.cpp b/src/codec/SkCodec.cpp
index d9992c0cd9..130fcd194f 100644
--- a/src/codec/SkCodec.cpp
+++ b/src/codec/SkCodec.cpp
@@ -174,7 +174,7 @@ bool SkCodec::conversionSupported(const SkImageInfo& dst, SkColorType srcColor,
             return srcIsOpaque;
         case kGray_8_SkColorType:
             return kGray_8_SkColorType == srcColor && srcIsOpaque &&
-                   !needs_color_xform(dst, srcCS, false);
+                   !needs_color_xform(dst, srcCS);
         case kAlpha_8_SkColorType:
             // conceptually we can convert anything into alpha_8, but we haven't actually coded
             // all of those other conversions yet, so only return true for the case we have codec.
@@ -247,7 +247,7 @@ SkCodec::Result SkCodec::handleFrameIndex(const SkImageInfo& info, void* pixels,
     if (0 == index) {
         if (!this->conversionSupported(info, fSrcInfo.colorType(), fEncodedInfo.opaque(),
                                       fSrcInfo.colorSpace())
-            || !this->initializeColorXform(info, fEncodedInfo.alpha(), options.fPremulBehavior))
+            || !this->initializeColorXform(info, fEncodedInfo.alpha()))
         {
             return kInvalidConversion;
         }
@@ -324,8 +324,7 @@ SkCodec::Result SkCodec::handleFrameIndex(const SkImageInfo& info, void* pixels,
         }
     }
 
-    return this->initializeColorXform(info, frame->reportedAlpha(), options.fPremulBehavior)
-        ? kSuccess : kInvalidConversion;
+    return this->initializeColorXform(info, frame->reportedAlpha()) ? kSuccess : kInvalidConversion;
 }
 
 SkCodec::Result SkCodec::getPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
@@ -648,8 +647,7 @@ static inline SkColorSpaceXform::ColorFormat select_xform_format_ct(SkColorType
     }
 }
 
-bool SkCodec::initializeColorXform(const SkImageInfo& dstInfo, SkEncodedInfo::Alpha encodedAlpha,
-                                   SkTransferFunctionBehavior premulBehavior) {
+bool SkCodec::initializeColorXform(const SkImageInfo& dstInfo, SkEncodedInfo::Alpha encodedAlpha) {
     fColorXform = nullptr;
     fXformOnDecode = false;
     if (!this->usesColorXform()) {
@@ -659,12 +657,8 @@ bool SkCodec::initializeColorXform(const SkImageInfo& dstInfo, SkEncodedInfo::Al
     // a colorXform to do a color correct premul, since the blend step will handle
     // premultiplication. But there is no way to know whether we need to blend from
     // inside this call.
-    bool needsColorCorrectPremul = needs_premul(dstInfo.alphaType(), encodedAlpha) &&
-                                   SkTransferFunctionBehavior::kRespect == premulBehavior;
-    if (needs_color_xform(dstInfo, fSrcInfo.colorSpace(), needsColorCorrectPremul)) {
-        fColorXform = SkMakeColorSpaceXform(fSrcInfo.colorSpace(),
-                                            dstInfo.colorSpace(),
-                                            premulBehavior);
+    if (needs_color_xform(dstInfo, fSrcInfo.colorSpace())) {
+        fColorXform = SkMakeColorSpaceXform(fSrcInfo.colorSpace(), dstInfo.colorSpace());
         if (!fColorXform) {
             return false;
         }
diff --git a/src/codec/SkCodecImageGenerator.cpp b/src/codec/SkCodecImageGenerator.cpp
index 6727dcf076..55a6575051 100644
--- a/src/codec/SkCodecImageGenerator.cpp
+++ b/src/codec/SkCodecImageGenerator.cpp
@@ -44,9 +44,7 @@ bool SkCodecImageGenerator::onGetPixels(const SkImageInfo& requestInfo, void* re
     SkPixmap dst(requestInfo, requestPixels, requestRowBytes);
 
     auto decode = [this](const SkPixmap& pm) {
-        SkCodec::Options codecOpts;
-        codecOpts.fPremulBehavior = SkTransferFunctionBehavior::kIgnore;
-        SkCodec::Result result = fCodec->getPixels(pm, &codecOpts);
+        SkCodec::Result result = fCodec->getPixels(pm);
         switch (result) {
             case SkCodec::kSuccess:
             case SkCodec::kIncompleteInput:
diff --git a/src/codec/SkCodecPriv.h b/src/codec/SkCodecPriv.h
index 1251d8d73c..65d457539e 100644
--- a/src/codec/SkCodecPriv.h
+++ b/src/codec/SkCodecPriv.h
@@ -276,20 +276,20 @@ static inline bool needs_premul(SkAlphaType dstAT, SkEncodedInfo::Alpha encodedA
     return kPremul_SkAlphaType == dstAT && SkEncodedInfo::kUnpremul_Alpha == encodedAlpha;
 }
 
-static inline bool needs_color_xform(const SkImageInfo& dstInfo, const SkColorSpace* srcCS,
-                                     bool needsColorCorrectPremul) {
+static inline bool needs_color_xform(const SkImageInfo& dstInfo, const SkColorSpace* srcCS) {
     // We never perform a color xform in legacy mode.
     if (!dstInfo.colorSpace()) {
         return false;
     }
 
-    // F16 is by definition a linear space, so we always must perform a color xform.
+    // None of the codecs we have output F16 natively, so if we're trying to decode to F16,
+    // we'll have to use SkColorSpaceXform to get there.
     bool isF16 = kRGBA_F16_SkColorType == dstInfo.colorType();
 
     // Need a color xform when dst space does not match the src.
     bool srcDstNotEqual = !SkColorSpace::Equals(srcCS, dstInfo.colorSpace());
 
-    return needsColorCorrectPremul || isF16 || srcDstNotEqual;
+    return isF16 || srcDstNotEqual;
 }
 
 static inline SkAlphaType select_xform_alpha(SkAlphaType dstAlphaType, SkAlphaType srcAlphaType) {
diff --git a/src/codec/SkSampledCodec.cpp b/src/codec/SkSampledCodec.cpp
index ac0539fc74..cf97b0b23f 100644
--- a/src/codec/SkSampledCodec.cpp
+++ b/src/codec/SkSampledCodec.cpp
@@ -75,7 +75,6 @@ SkCodec::Result SkSampledCodec::onGetAndroidPixels(const SkImageInfo& info, void
     // Create an Options struct for the codec.
     SkCodec::Options codecOptions;
     codecOptions.fZeroInitialized = options.fZeroInitialized;
-    codecOptions.fPremulBehavior = SkTransferFunctionBehavior::kIgnore;
 
     SkIRect* subset = options.fSubset;
     if (!subset || subset->size() == this->codec()->getInfo().dimensions()) {
@@ -170,7 +169,6 @@ SkCodec::Result SkSampledCodec::sampledDecode(const SkImageInfo& info, void* pix
     // Create options struct for the codec.
     SkCodec::Options sampledOptions;
     sampledOptions.fZeroInitialized = options.fZeroInitialized;
-    sampledOptions.fPremulBehavior = SkTransferFunctionBehavior::kIgnore;
 
     // FIXME: This was already called by onGetAndroidPixels. Can we reduce that?
     int sampleSize = options.fSampleSize;
diff --git a/src/codec/SkWebpAdapterCodec.cpp b/src/codec/SkWebpAdapterCodec.cpp
index 81011d017b..79a99a72f0 100644
--- a/src/codec/SkWebpAdapterCodec.cpp
+++ b/src/codec/SkWebpAdapterCodec.cpp
@@ -27,6 +27,5 @@ SkCodec::Result SkWebpAdapterCodec::onGetAndroidPixels(const SkImageInfo& info,
     SkCodec::Options codecOptions;
     codecOptions.fZeroInitialized = options.fZeroInitialized;
     codecOptions.fSubset = options.fSubset;
-    codecOptions.fPremulBehavior = SkTransferFunctionBehavior::kIgnore;
     return this->codec()->getPixels(info, pixels, rowBytes, &codecOptions);
 }
diff --git a/src/codec/SkWebpCodec.cpp b/src/codec/SkWebpCodec.cpp
index b6485b1b9c..bb6e430790 100644
--- a/src/codec/SkWebpCodec.cpp
+++ b/src/codec/SkWebpCodec.cpp
@@ -514,14 +514,6 @@ SkCodec::Result SkWebpCodec::onGetPixels(const SkImageInfo& dstInfo, void* dst,
 
     const bool blendWithPrevFrame = !independent && frame.blend_method == WEBP_MUX_BLEND
         && frame.has_alpha;
-    if (blendWithPrevFrame && options.fPremulBehavior == SkTransferFunctionBehavior::kRespect) {
-        // Blending is done with SkRasterPipeline, which requires a color space that is valid for
-        // rendering.
-        const auto* cs = dstInfo.colorSpace();
-        if (!cs || (!cs->gammaCloseToSRGB() && !cs->gammaIsLinear())) {
-            return kInvalidConversion;
-        }
-    }
 
     SkBitmap webpDst;
     auto webpInfo = dstInfo;
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 4ef7abf95c..6d936f9436 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -494,8 +494,7 @@ bool SkBitmap::readPixels(const SkPixmap& dst, int srcX, int srcY) const {
     return this->readPixels(dst.info(), dst.writable_addr(), dst.rowBytes(), srcX, srcY);
 }
 
-bool SkBitmap::writePixels(const SkPixmap& src, int dstX, int dstY,
-                           SkTransferFunctionBehavior behavior) {
+bool SkBitmap::writePixels(const SkPixmap& src, int dstX, int dstY, SkTransferFunctionBehavior) {
     if (!SkImageInfoValidConversion(this->info(), src.info())) {
         return false;
     }
@@ -507,8 +506,7 @@ bool SkBitmap::writePixels(const SkPixmap& src, int dstX, int dstY,
 
     void* dstPixels = this->getAddr(rec.fX, rec.fY);
     const SkImageInfo dstInfo = this->info().makeWH(rec.fInfo.width(), rec.fInfo.height());
-    SkConvertPixels(dstInfo, dstPixels, this->rowBytes(), rec.fInfo, rec.fPixels, rec.fRowBytes,
-                    behavior);
+    SkConvertPixels(dstInfo, dstPixels, this->rowBytes(), rec.fInfo, rec.fPixels, rec.fRowBytes);
     this->notifyPixelsChanged();
     return true;
 }
@@ -528,8 +526,7 @@ static bool GetBitmapAlpha(const SkBitmap& src, uint8_t* SK_RESTRICT alpha, int
         return false;
     }
     SkConvertPixels(SkImageInfo::MakeA8(pmap.width(), pmap.height()), alpha, alphaRowBytes,
-                    pmap.info(), pmap.addr(), pmap.rowBytes(),
-                    SkTransferFunctionBehavior::kRespect);
+                    pmap.info(), pmap.addr(), pmap.rowBytes());
     return true;
 }
 
diff --git a/src/core/SkColorSpaceXform.cpp b/src/core/SkColorSpaceXform.cpp
index 213e5b501e..5418c588fd 100644
--- a/src/core/SkColorSpaceXform.cpp
+++ b/src/core/SkColorSpaceXform.cpp
@@ -12,7 +12,7 @@
 #include "../../third_party/skcms/skcms.h"
 
 std::unique_ptr<SkColorSpaceXform> SkColorSpaceXform::New(SkColorSpace* src, SkColorSpace* dst) {
-    return SkMakeColorSpaceXform(src, dst, SkTransferFunctionBehavior::kRespect);
+    return SkMakeColorSpaceXform(src, dst);
 }
 
 bool SkColorSpaceXform::Apply(SkColorSpace* dstCS, ColorFormat dstFormat, void* dst,
@@ -30,11 +30,9 @@ bool SkColorSpaceXform::Apply(SkColorSpace* dstCS, ColorFormat dstFormat, void*
 class SkColorSpaceXform_skcms : public SkColorSpaceXform {
 public:
     SkColorSpaceXform_skcms(const skcms_ICCProfile& srcProfile,
-                            const skcms_ICCProfile& dstProfile,
-                            skcms_AlphaFormat premulFormat)
+                            const skcms_ICCProfile& dstProfile)
         : fSrcProfile(srcProfile)
-        , fDstProfile(dstProfile)
-        , fPremulFormat(premulFormat) {
+        , fDstProfile(dstProfile) {
     }
 
     bool apply(ColorFormat, void*, ColorFormat, const void*, int, SkAlphaType) const override;
@@ -42,7 +40,6 @@ public:
 private:
     skcms_ICCProfile  fSrcProfile;
     skcms_ICCProfile  fDstProfile;
-    skcms_AlphaFormat fPremulFormat;
 };
 
 static skcms_PixelFormat get_skcms_format(SkColorSpaceXform::ColorFormat fmt) {
@@ -71,7 +68,8 @@ bool SkColorSpaceXform_skcms::apply(ColorFormat dstFormat, void* dst,
                                     ColorFormat srcFormat, const void* src,
                                     int count, SkAlphaType alphaType) const {
     skcms_AlphaFormat srcAlpha = skcms_AlphaFormat_Unpremul;
-    skcms_AlphaFormat dstAlpha = kPremul_SkAlphaType == alphaType ? fPremulFormat
+    skcms_AlphaFormat dstAlpha = kPremul_SkAlphaType == alphaType
+        ? skcms_AlphaFormat_PremulAsEncoded
         : skcms_AlphaFormat_Unpremul;
 
     return skcms_Transform(src, get_skcms_format(srcFormat), srcAlpha, &fSrcProfile,
@@ -98,12 +96,10 @@ void SkColorSpace::toProfile(skcms_ICCProfile* profile) const {
     }
 }
 
-std::unique_ptr<SkColorSpaceXform> SkMakeColorSpaceXform(SkColorSpace* src, SkColorSpace* dst,
-                                                         SkTransferFunctionBehavior premul) {
+std::unique_ptr<SkColorSpaceXform> SkMakeColorSpaceXform(SkColorSpace* src, SkColorSpace* dst) {
     if (src && dst && dst->toXYZD50()) {
         // Construct skcms_ICCProfiles from each color space. For now, support A2B and XYZ.
-        // Eventually, only need to support XYZ. Map premul to one of the two premul formats
-        // in skcms.
+        // Eventually, only need to support XYZ.
         skcms_ICCProfile srcProfile, dstProfile;
 
         src->toProfile(&srcProfile);
@@ -113,10 +109,7 @@ std::unique_ptr<SkColorSpaceXform> SkMakeColorSpaceXform(SkColorSpace* src, SkCo
             return nullptr;
         }
 
-        skcms_AlphaFormat premulFormat = SkTransferFunctionBehavior::kRespect == premul
-            ? skcms_AlphaFormat_PremulLinear
-            : skcms_AlphaFormat_PremulAsEncoded;
-        return skstd::make_unique<SkColorSpaceXform_skcms>(srcProfile, dstProfile, premulFormat);
+        return skstd::make_unique<SkColorSpaceXform_skcms>(srcProfile, dstProfile);
     }
     return nullptr;
 }
diff --git a/src/core/SkColorSpaceXformPriv.h b/src/core/SkColorSpaceXformPriv.h
index 301e741380..f75ebf438c 100644
--- a/src/core/SkColorSpaceXformPriv.h
+++ b/src/core/SkColorSpaceXformPriv.h
@@ -10,13 +10,7 @@
 
 #include "SkColorSpaceXform.h"
 
-std::unique_ptr<SkColorSpaceXform> SkMakeColorSpaceXform(SkColorSpace* src,
-                                                         SkColorSpace* dst,
-                                                         SkTransferFunctionBehavior);
-
-std::unique_ptr<SkColorSpaceXform> SkMakeColorSpaceXform_skcms(SkColorSpace* src,
-                                                              SkColorSpace* dst,
-                                                              SkTransferFunctionBehavior);
+std::unique_ptr<SkColorSpaceXform> SkMakeColorSpaceXform(SkColorSpace* src, SkColorSpace* dst);
 
 static inline SkColorSpaceXform::ColorFormat select_xform_format(SkColorType colorType) {
     switch (colorType) {
diff --git a/src/core/SkColorSpaceXformer.cpp b/src/core/SkColorSpaceXformer.cpp
index 0b536ff8f4..5329294982 100644
--- a/src/core/SkColorSpaceXformer.cpp
+++ b/src/core/SkColorSpaceXformer.cpp
@@ -26,7 +26,7 @@ SkColorSpaceXformer::~SkColorSpaceXformer() {}
 
 std::unique_ptr<SkColorSpaceXformer> SkColorSpaceXformer::Make(sk_sp<SkColorSpace> dst) {
     std::unique_ptr<SkColorSpaceXform> fromSRGB = SkMakeColorSpaceXform(
-            SkColorSpace::MakeSRGB().get(), dst.get(), SkTransferFunctionBehavior::kIgnore);
+            SkColorSpace::MakeSRGB().get(), dst.get());
 
     return fromSRGB
         ? std::unique_ptr<SkColorSpaceXformer>(new SkColorSpaceXformer(std::move(dst),
@@ -98,7 +98,7 @@ sk_sp<SkImage> SkColorSpaceXformer::apply(const SkImage* src) {
     const AutoCachePurge autoPurge(this);
     return this->cachedApply<SkImage>(src, &fImageCache,
         [](const SkImage* img, SkColorSpaceXformer* xformer) {
-            return img->makeColorSpace(xformer->fDst, SkTransferFunctionBehavior::kIgnore);
+            return img->makeColorSpace(xformer->fDst);
         });
 }
 
@@ -109,7 +109,7 @@ sk_sp<SkImage> SkColorSpaceXformer::apply(const SkBitmap& src) {
         return nullptr;
     }
 
-    sk_sp<SkImage> xformed = image->makeColorSpace(fDst, SkTransferFunctionBehavior::kIgnore);
+    sk_sp<SkImage> xformed = image->makeColorSpace(fDst);
     // We want to be sure we don't let the kNever_SkCopyPixelsMode image escape this stack frame.
     SkASSERT(xformed != image);
     return xformed;
diff --git a/src/core/SkConvertPixels.cpp b/src/core/SkConvertPixels.cpp
index 0434b92c2e..ac96f20c86 100644
--- a/src/core/SkConvertPixels.cpp
+++ b/src/core/SkConvertPixels.cpp
@@ -87,13 +87,10 @@ void swizzle_and_multiply(const SkImageInfo& dstInfo, void* dstPixels, size_t ds
 }
 
 // Fast Path 3: Color space xform.
-static inline bool optimized_color_xform(const SkImageInfo& dstInfo, const SkImageInfo& srcInfo,
-                                         SkTransferFunctionBehavior behavior) {
+static inline bool optimized_color_xform(const SkImageInfo& dstInfo, const SkImageInfo& srcInfo) {
     // Unpremultiplication is unsupported by SkColorSpaceXform.  Note that if |src| is non-linearly
     // premultiplied, we're always going to have to unpremultiply before doing anything.
-    if (kPremul_SkAlphaType == srcInfo.alphaType() &&
-            (kUnpremul_SkAlphaType == dstInfo.alphaType() ||
-             SkTransferFunctionBehavior::kIgnore == behavior)) {
+    if (kPremul_SkAlphaType == srcInfo.alphaType()) {
         return false;
     }
 
@@ -119,7 +116,7 @@ static inline bool optimized_color_xform(const SkImageInfo& dstInfo, const SkIma
 
 static inline bool apply_color_xform(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB,
                                      const SkImageInfo& srcInfo, const void* srcPixels,
-                                     size_t srcRB, SkTransferFunctionBehavior behavior) {
+                                     size_t srcRB) {
     SkColorSpaceXform::ColorFormat dstFormat = select_xform_format(dstInfo.colorType());
     SkColorSpaceXform::ColorFormat srcFormat = select_xform_format(srcInfo.colorType());
     SkAlphaType xformAlpha;
@@ -146,8 +143,8 @@ static inline bool apply_color_xform(const SkImageInfo& dstInfo, void* dstPixels
             break;
     }
 
-    std::unique_ptr<SkColorSpaceXform> xform =
-            SkMakeColorSpaceXform(srcInfo.colorSpace(), dstInfo.colorSpace(), behavior);
+    std::unique_ptr<SkColorSpaceXform> xform = SkMakeColorSpaceXform(srcInfo.colorSpace(),
+                                                                     dstInfo.colorSpace());
     if (!xform) {
         return false;
     }
@@ -250,7 +247,7 @@ static void convert_to_alpha8(uint8_t* dst, size_t dstRB, const SkImageInfo& src
 // Default: Use the pipeline.
 static void convert_with_pipeline(const SkImageInfo& dstInfo, void* dstRow, size_t dstRB,
                                   const SkImageInfo& srcInfo, const void* srcRow, size_t srcRB,
-                                  bool isColorAware, SkTransferFunctionBehavior behavior) {
+                                  bool isColorAware) {
 
     SkJumper_MemoryCtx src = { (void*)srcRow, (int)(srcRB / srcInfo.bytesPerPixel()) },
                        dst = { (void*)dstRow, (int)(dstRB / dstInfo.bytesPerPixel()) };
@@ -295,7 +292,7 @@ static void convert_with_pipeline(const SkImageInfo& dstInfo, void* dstRow, size
     }
 
     SkAlphaType premulState = srcInfo.alphaType();
-    if (kPremul_SkAlphaType == premulState && SkTransferFunctionBehavior::kIgnore == behavior) {
+    if (kPremul_SkAlphaType == premulState) {
         pipeline.append(SkRasterPipeline::unpremul);
         premulState = kUnpremul_SkAlphaType;
     }
@@ -318,17 +315,6 @@ static void convert_with_pipeline(const SkImageInfo& dstInfo, void* dstRow, size
                                srcInfo.colorSpace(), dstInfo.colorSpace(), premulState);
     }
 
-    SkAlphaType dat = dstInfo.alphaType();
-    if (SkTransferFunctionBehavior::kRespect == behavior) {
-        if (kPremul_SkAlphaType == premulState && kUnpremul_SkAlphaType == dat) {
-            pipeline.append(SkRasterPipeline::unpremul);
-            premulState = kUnpremul_SkAlphaType;
-        } else if (kUnpremul_SkAlphaType == premulState && kPremul_SkAlphaType == dat) {
-            pipeline.append(SkRasterPipeline::premul);
-            premulState = kPremul_SkAlphaType;
-        }
-    }
-
     SkColorSpaceTransferFn dstFn;
     if (isColorAware && dstInfo.gammaCloseToSRGB()) {
         pipeline.append(SkRasterPipeline::to_srgb);
@@ -342,8 +328,8 @@ static void convert_with_pipeline(const SkImageInfo& dstInfo, void* dstRow, size
         }
     }
 
-    if (kUnpremul_SkAlphaType == premulState && kPremul_SkAlphaType == dat &&
-        SkTransferFunctionBehavior::kIgnore == behavior)
+    SkAlphaType dat = dstInfo.alphaType();
+    if (kUnpremul_SkAlphaType == premulState && kPremul_SkAlphaType == dat)
     {
         pipeline.append(SkRasterPipeline::premul);
         premulState = kPremul_SkAlphaType;
@@ -415,8 +401,7 @@ static bool swizzle_and_multiply_color_type(SkColorType ct) {
 }
 
 void SkConvertPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB,
-                     const SkImageInfo& srcInfo, const void* srcPixels, size_t srcRB,
-                     SkTransferFunctionBehavior behavior) {
+                     const SkImageInfo& srcInfo, const void* srcPixels, size_t srcRB) {
     SkASSERT(dstInfo.dimensions() == srcInfo.dimensions());
     SkASSERT(SkImageInfoValidConversion(dstInfo, srcInfo));
 
@@ -437,8 +422,8 @@ void SkConvertPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB,
     }
 
     // Fast Path 3: Color space xform.
-    if (isColorAware && optimized_color_xform(dstInfo, srcInfo, behavior)) {
-        if (apply_color_xform(dstInfo, dstPixels, dstRB, srcInfo, srcPixels, srcRB, behavior)) {
+    if (isColorAware && optimized_color_xform(dstInfo, srcInfo)) {
+        if (apply_color_xform(dstInfo, dstPixels, dstRB, srcInfo, srcPixels, srcRB)) {
             return;
         }
     }
@@ -450,6 +435,5 @@ void SkConvertPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB,
     }
 
     // Default: Use the pipeline.
-    convert_with_pipeline(dstInfo, dstPixels, dstRB, srcInfo, srcPixels, srcRB, isColorAware,
-                          behavior);
+    convert_with_pipeline(dstInfo, dstPixels, dstRB, srcInfo, srcPixels, srcRB, isColorAware);
 }
diff --git a/src/core/SkConvertPixels.h b/src/core/SkConvertPixels.h
index 001052b7a8..ccd76c35a7 100644
--- a/src/core/SkConvertPixels.h
+++ b/src/core/SkConvertPixels.h
@@ -14,8 +14,7 @@
 class SkColorTable;
 
 void SkConvertPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
-                     const SkImageInfo& srcInfo, const void* srcPixels, size_t srcRowBytes,
-                     SkTransferFunctionBehavior behavior);
+                     const SkImageInfo& srcInfo, const void* srcPixels, size_t srcRowBytes);
 
 static inline void SkRectMemcpy(void* dst, size_t dstRB, const void* src, size_t srcRB,
                                 size_t bytesPerRow, int rowCount) {
diff --git a/src/core/SkPixmap.cpp b/src/core/SkPixmap.cpp
index 77b174b154..d91b3cc9c1 100644
--- a/src/core/SkPixmap.cpp
+++ b/src/core/SkPixmap.cpp
@@ -81,7 +81,7 @@ bool SkPixmap::extractSubset(SkPixmap* result, const SkIRect& subset) const {
 }
 
 bool SkPixmap::readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB, int x, int y,
-                          SkTransferFunctionBehavior behavior) const {
+                          SkTransferFunctionBehavior) const {
     if (!SkImageInfoValidConversion(dstInfo, fInfo)) {
         return false;
     }
@@ -93,8 +93,7 @@ bool SkPixmap::readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t ds
 
     const void* srcPixels = this->addr(rec.fX, rec.fY);
     const SkImageInfo srcInfo = fInfo.makeWH(rec.fInfo.width(), rec.fInfo.height());
-    SkConvertPixels(rec.fInfo, rec.fPixels, rec.fRowBytes, srcInfo, srcPixels, this->rowBytes(),
-                    behavior);
+    SkConvertPixels(rec.fInfo, rec.fPixels, rec.fRowBytes, srcInfo, srcPixels, this->rowBytes());
     return true;
 }
 
diff --git a/src/image/SkImage.cpp b/src/image/SkImage.cpp
index 128e693ad2..53add0e9d3 100644
--- a/src/image/SkImage.cpp
+++ b/src/image/SkImage.cpp
@@ -295,7 +295,7 @@ bool SkImage::isAlphaOnly() const {
 }
 
 sk_sp<SkImage> SkImage::makeColorSpace(sk_sp<SkColorSpace> target,
-                                       SkTransferFunctionBehavior premulBehavior) const {
+                                       SkTransferFunctionBehavior) const {
     SkColorSpaceTransferFn fn;
     if (!target || !target->isNumericalTransferFn(&fn)) {
         return nullptr;
@@ -309,13 +309,11 @@ sk_sp<SkImage> SkImage::makeColorSpace(sk_sp<SkColorSpace> target,
         return sk_ref_sp(const_cast<SkImage*>(this));
     }
 
+    // TODO: Re-visit this! Keep existing color type?
     SkColorType targetColorType = kN32_SkColorType;
-    if (SkTransferFunctionBehavior::kRespect == premulBehavior && target->gammaIsLinear()) {
-        targetColorType = kRGBA_F16_SkColorType;
-    }
 
     // TODO: We might consider making this a deferred conversion?
-    return as_IB(this)->onMakeColorSpace(std::move(target), targetColorType, premulBehavior);
+    return as_IB(this)->onMakeColorSpace(std::move(target), targetColorType);
 }
 
 sk_sp<SkImage> SkImage::makeNonTextureImage() const {
diff --git a/src/image/SkImage_Base.h b/src/image/SkImage_Base.h
index 0d54a39471..6a048ba51f 100644
--- a/src/image/SkImage_Base.h
+++ b/src/image/SkImage_Base.h
@@ -95,8 +95,7 @@ public:
     virtual bool onPinAsTexture(GrContext*) const { return false; }
     virtual void onUnpinAsTexture(GrContext*) const {}
 
-    virtual sk_sp<SkImage> onMakeColorSpace(sk_sp<SkColorSpace>, SkColorType,
-                                            SkTransferFunctionBehavior) const = 0;
+    virtual sk_sp<SkImage> onMakeColorSpace(sk_sp<SkColorSpace>, SkColorType) const = 0;
 protected:
     SkImage_Base(int width, int height, uint32_t uniqueID);
 
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index 359782f745..0fcc01f0f0 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -950,13 +950,7 @@ bool SkImage::MakeBackendTextureFromSkImage(GrContext* ctx,
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-sk_sp<SkImage> SkImage_Gpu::onMakeColorSpace(sk_sp<SkColorSpace> target, SkColorType,
-                                             SkTransferFunctionBehavior premulBehavior) const {
-    if (SkTransferFunctionBehavior::kRespect == premulBehavior) {
-        // TODO: Implement this.
-        return nullptr;
-    }
-
+sk_sp<SkImage> SkImage_Gpu::onMakeColorSpace(sk_sp<SkColorSpace> target, SkColorType) const {
     sk_sp<SkColorSpace> srcSpace = fColorSpace;
     if (!fColorSpace) {
         if (target->isSRGB()) {
diff --git a/src/image/SkImage_Gpu.h b/src/image/SkImage_Gpu.h
index c79e5295be..57c38c10fd 100644
--- a/src/image/SkImage_Gpu.h
+++ b/src/image/SkImage_Gpu.h
@@ -60,8 +60,7 @@ public:
 
     sk_sp<SkColorSpace> refColorSpace() { return fColorSpace; }
 
-    sk_sp<SkImage> onMakeColorSpace(sk_sp<SkColorSpace>, SkColorType,
-                                    SkTransferFunctionBehavior) const override;
+    sk_sp<SkImage> onMakeColorSpace(sk_sp<SkColorSpace>, SkColorType) const override;
 
     typedef ReleaseContext TextureContext;
     typedef void (*TextureFulfillProc)(TextureContext textureContext, GrBackendTexture* outTexture);
diff --git a/src/image/SkImage_Lazy.cpp b/src/image/SkImage_Lazy.cpp
index 8d8e95219d..402acf5d73 100644
--- a/src/image/SkImage_Lazy.cpp
+++ b/src/image/SkImage_Lazy.cpp
@@ -94,8 +94,7 @@ public:
     bool getROPixels(SkBitmap*, SkColorSpace* dstColorSpace, CachingHint) const override;
     bool onIsLazyGenerated() const override { return true; }
     bool onCanLazyGenerateOnGPU() const override;
-    sk_sp<SkImage> onMakeColorSpace(sk_sp<SkColorSpace>, SkColorType,
-                                    SkTransferFunctionBehavior) const override;
+    sk_sp<SkImage> onMakeColorSpace(sk_sp<SkColorSpace>, SkColorType) const override;
 
     bool onIsValid(GrContext*) const override;
 
@@ -451,8 +450,7 @@ sk_sp<SkImage> SkImage_Lazy::onMakeSubset(const SkIRect& subset) const {
 }
 
 sk_sp<SkImage> SkImage_Lazy::onMakeColorSpace(sk_sp<SkColorSpace> target,
-                                              SkColorType targetColorType,
-                                              SkTransferFunctionBehavior premulBehavior) const {
+                                              SkColorType targetColorType) const {
     SkAutoExclusive autoAquire(fOnMakeColorSpaceMutex);
     if (target && fOnMakeColorSpaceTarget &&
         SkColorSpace::Equals(target.get(), fOnMakeColorSpaceTarget.get())) {
diff --git a/src/image/SkImage_Raster.cpp b/src/image/SkImage_Raster.cpp
index ca01780d36..859014f398 100644
--- a/src/image/SkImage_Raster.cpp
+++ b/src/image/SkImage_Raster.cpp
@@ -110,8 +110,7 @@ public:
         SkASSERT(bitmapMayBeMutable || fBitmap.isImmutable());
     }
 
-    sk_sp<SkImage> onMakeColorSpace(sk_sp<SkColorSpace>, SkColorType,
-                                    SkTransferFunctionBehavior) const override;
+    sk_sp<SkImage> onMakeColorSpace(sk_sp<SkColorSpace>, SkColorType) const override;
 
     bool onIsValid(GrContext* context) const override { return true; }
 
@@ -343,8 +342,7 @@ bool SkImage_Raster::onAsLegacyBitmap(SkBitmap* bitmap) const {
 ///////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkImage> SkImage_Raster::onMakeColorSpace(sk_sp<SkColorSpace> target,
-                                                SkColorType targetColorType,
-                                                SkTransferFunctionBehavior premulBehavior) const {
+                                                SkColorType targetColorType) const {
     SkPixmap src;
     SkAssertResult(fBitmap.peekPixels(&src));
 
@@ -361,7 +359,7 @@ sk_sp<SkImage> SkImage_Raster::onMakeColorSpace(sk_sp<SkColorSpace> target,
     SkBitmap dst;
     dst.allocPixels(dstInfo);
 
-    SkAssertResult(dst.writePixels(src, 0, 0, premulBehavior));
+    SkAssertResult(dst.writePixels(src, 0, 0));
     dst.setImmutable();
     return SkImage::MakeFromBitmap(dst);
 }
diff --git a/src/images/SkImageEncoder.cpp b/src/images/SkImageEncoder.cpp
index 7472a02f51..946a67f231 100644
--- a/src/images/SkImageEncoder.cpp
+++ b/src/images/SkImageEncoder.cpp
@@ -40,19 +40,16 @@ bool SkEncodeImage(SkWStream* dst, const SkPixmap& src,
             case SkEncodedImageFormat::kJPEG: {
                 SkJpegEncoder::Options opts;
                 opts.fQuality = quality;
-                opts.fBlendBehavior = SkTransferFunctionBehavior::kIgnore;
                 return SkJpegEncoder::Encode(dst, src, opts);
             }
             case SkEncodedImageFormat::kPNG: {
                 SkPngEncoder::Options opts;
-                opts.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
                 return SkPngEncoder::Encode(dst, src, opts);
             }
             case SkEncodedImageFormat::kWEBP: {
                 SkWebpEncoder::Options opts;
                 opts.fCompression = SkWebpEncoder::Compression::kLossy;
                 opts.fQuality = quality;
-                opts.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
                 return SkWebpEncoder::Encode(dst, src, opts);
             }
             default:
diff --git a/src/images/SkImageEncoderFns.h b/src/images/SkImageEncoderFns.h
index 6bf0081b26..cd9972952d 100644
--- a/src/images/SkImageEncoderFns.h
+++ b/src/images/SkImageEncoderFns.h
@@ -163,24 +163,6 @@ static inline void transform_scanline_bgrA(char* SK_RESTRICT dst, const char* SK
     SkUnpremultiplyRow<true>((uint32_t*) dst, (const uint32_t*) src, width);
 }
 
-template <bool kIsRGBA>
-static inline void transform_scanline_unpremultiply_sRGB(void* dst, const void* src, int width) {
-    SkJumper_MemoryCtx src_ctx = { (void*)src, 0 },
-                       dst_ctx = { (void*)dst, 0 };
-    SkRasterPipeline_<256> p;
-    if (kIsRGBA) {
-        p.append(SkRasterPipeline::load_8888, &src_ctx);
-    } else {
-        p.append(SkRasterPipeline::load_bgra, &src_ctx);
-    }
-
-    p.append(SkRasterPipeline::from_srgb);
-    p.append(SkRasterPipeline::unpremul);
-    p.append(SkRasterPipeline::to_srgb);
-    p.append(SkRasterPipeline::store_8888, &dst_ctx);
-    p.run(0,0, width,1);
-}
-
 /**
  * Premultiply RGBA to rgbA.
  */
@@ -191,39 +173,6 @@ static inline void transform_scanline_to_premul_legacy(char* SK_RESTRICT dst,
 }
 
 /**
- * Premultiply RGBA to rgbA linearly.
- */
-static inline void transform_scanline_to_premul_linear(char* SK_RESTRICT dst,
-                                                       const char* SK_RESTRICT src,
-                                                       int width, int, const SkPMColor*) {
-    SkJumper_MemoryCtx src_ctx = { (void*)src, 0 },
-                       dst_ctx = { (void*)dst, 0 };
-    SkRasterPipeline_<256> p;
-    p.append(SkRasterPipeline::load_8888, &src_ctx);
-    p.append(SkRasterPipeline::from_srgb);
-    p.append(SkRasterPipeline::premul);
-    p.append(SkRasterPipeline::to_srgb);
-    p.append(SkRasterPipeline::store_8888, &dst_ctx);
-    p.run(0,0, width,1);
-}
-
-/**
- * Transform from kPremul, kRGBA_8888_SkColorType to 4-bytes-per-pixel unpremultiplied RGBA.
- */
-static inline void transform_scanline_srgbA(char* SK_RESTRICT dst, const char* SK_RESTRICT src,
-                                            int width, int, const SkPMColor*) {
-    transform_scanline_unpremultiply_sRGB<true>(dst, src, width);
-}
-
-/**
- * Transform from kPremul, kBGRA_8888_SkColorType to 4-bytes-per-pixel unpremultiplied RGBA.
- */
-static inline void transform_scanline_sbgrA(char* SK_RESTRICT dst, const char* SK_RESTRICT src,
-                                            int width, int, const SkPMColor*) {
-    transform_scanline_unpremultiply_sRGB<false>(dst, src, width);
-}
-
-/**
  * Transform from kUnpremul, kBGRA_8888_SkColorType to 4-bytes-per-pixel unpremultiplied RGBA.
  */
 static inline void transform_scanline_BGRA(char* SK_RESTRICT dst, const char* SK_RESTRICT src,
@@ -336,7 +285,6 @@ static inline void transform_scanline_F16(char* SK_RESTRICT dst, const char* SK_
     p.append(SkRasterPipeline::load_f16, &src_ctx);
     p.append(SkRasterPipeline::clamp_0);  // F16 values may be out of [0,1] range, so clamp.
     p.append(SkRasterPipeline::clamp_1);
-    p.append(SkRasterPipeline::to_srgb);
     p.append(SkRasterPipeline::store_u16_be, &dst_ctx);
     p.run(0,0, width,1);
 }
@@ -353,7 +301,6 @@ static inline void transform_scanline_F16_premul(char* SK_RESTRICT dst, const ch
     p.append(SkRasterPipeline::unpremul);
     p.append(SkRasterPipeline::clamp_0);  // F16 values may be out of [0,1] range, so clamp.
     p.append(SkRasterPipeline::clamp_1);
-    p.append(SkRasterPipeline::to_srgb);
     p.append(SkRasterPipeline::store_u16_be, &dst_ctx);
     p.run(0,0, width,1);
 }
@@ -370,7 +317,6 @@ static inline void transform_scanline_F16_to_8888(char* SK_RESTRICT dst,
     p.append(SkRasterPipeline::load_f16, &src_ctx);
     p.append(SkRasterPipeline::clamp_0);  // F16 values may be out of [0,1] range, so clamp.
     p.append(SkRasterPipeline::clamp_1);
-    p.append(SkRasterPipeline::to_srgb);
     p.append(SkRasterPipeline::store_8888, &dst_ctx);
     p.run(0,0, width,1);
 }
@@ -388,7 +334,6 @@ static inline void transform_scanline_F16_premul_to_8888(char* SK_RESTRICT dst,
     p.append(SkRasterPipeline::unpremul);
     p.append(SkRasterPipeline::clamp_0);  // F16 values may be out of [0,1] range, so clamp.
     p.append(SkRasterPipeline::clamp_1);
-    p.append(SkRasterPipeline::to_srgb);
     p.append(SkRasterPipeline::store_8888, &dst_ctx);
     p.run(0,0, width,1);
 }
@@ -405,7 +350,6 @@ static inline void transform_scanline_F16_to_premul_8888(char* SK_RESTRICT dst,
     p.append(SkRasterPipeline::clamp_0);  // F16 values may be out of [0,1] range, so clamp.
     p.append(SkRasterPipeline::clamp_1);
     p.append(SkRasterPipeline::premul);
-    p.append(SkRasterPipeline::to_srgb);
     p.append(SkRasterPipeline::store_8888, &dst_ctx);
     p.run(0,0, width,1);
 }
@@ -421,7 +365,6 @@ static inline void transform_scanline_F32(char* SK_RESTRICT dst, const char* SK_
     p.append(SkRasterPipeline::load_f32, &src_ctx);
     p.append(SkRasterPipeline::clamp_0);  // F32 values may be out of [0,1] range, so clamp.
     p.append(SkRasterPipeline::clamp_1);
-    p.append(SkRasterPipeline::to_srgb);
     p.append(SkRasterPipeline::store_u16_be, &dst_ctx);
     p.run(0,0, width,1);
 }
@@ -438,7 +381,6 @@ static inline void transform_scanline_F32_premul(char* SK_RESTRICT dst, const ch
     p.append(SkRasterPipeline::unpremul);
     p.append(SkRasterPipeline::clamp_0);  // F32 values may be out of [0,1] range, so clamp.
     p.append(SkRasterPipeline::clamp_1);
-    p.append(SkRasterPipeline::to_srgb);
     p.append(SkRasterPipeline::store_u16_be, &dst_ctx);
     p.run(0,0, width,1);
 }
@@ -449,13 +391,6 @@ static inline sk_sp<SkData> icc_from_color_space(const SkImageInfo& info) {
         return nullptr;
     }
 
-    sk_sp<SkColorSpace> owned;
-    if (kRGBA_F16_SkColorType == info.colorType() ||
-        kRGBA_F32_SkColorType == info.colorType()) {
-        owned = cs->makeSRGBGamma();
-        cs = owned.get();
-    }
-
     SkColorSpaceTransferFn fn;
     SkMatrix44 toXYZD50(SkMatrix44::kUninitialized_Constructor);
     if (cs->isNumericalTransferFn(&fn) && cs->toXYZD50(&toXYZD50)) {
diff --git a/src/images/SkJpegEncoder.cpp b/src/images/SkJpegEncoder.cpp
index 9c139f707b..1c1fb15e2e 100644
--- a/src/images/SkJpegEncoder.cpp
+++ b/src/images/SkJpegEncoder.cpp
@@ -74,15 +74,7 @@ bool SkJpegEncoderMgr::setParams(const SkImageInfo& srcInfo, const SkJpegEncoder
             return (transform_scanline_proc) nullptr;
         }
 
-        // Note that kRespect mode is only supported with sRGB or linear transfer functions.
-        // The legacy code path is incidentally correct when the transfer function is linear.
-        const bool isSRGBTransferFn = srcInfo.gammaCloseToSRGB() &&
-                (SkTransferFunctionBehavior::kRespect == options.fBlendBehavior);
-        if (isSRGBTransferFn) {
-            return transform_scanline_to_premul_linear;
-        } else {
-            return transform_scanline_to_premul_legacy;
-        }
+        return transform_scanline_to_premul_legacy;
     };
 
     J_COLOR_SPACE jpegColorType = JCS_EXT_RGBA;
@@ -118,8 +110,7 @@ bool SkJpegEncoderMgr::setParams(const SkImageInfo& srcInfo, const SkJpegEncoder
             numComponents = 1;
             break;
         case kRGBA_F16_SkColorType:
-            if (!srcInfo.colorSpace() ||
-                    SkTransferFunctionBehavior::kRespect != options.fBlendBehavior) {
+            if (!srcInfo.colorSpace()) {
                 return false;
             }
 
diff --git a/src/images/SkPngEncoder.cpp b/src/images/SkPngEncoder.cpp
index 7520b9044d..0ca2551735 100644
--- a/src/images/SkPngEncoder.cpp
+++ b/src/images/SkPngEncoder.cpp
@@ -55,7 +55,7 @@ public:
     bool setHeader(const SkImageInfo& srcInfo, const SkPngEncoder::Options& options);
     bool setColorSpace(const SkImageInfo& info);
     bool writeInfo(const SkImageInfo& srcInfo);
-    void chooseProc(const SkImageInfo& srcInfo, SkTransferFunctionBehavior unpremulBehavior);
+    void chooseProc(const SkImageInfo& srcInfo);
 
     png_structp pngPtr() { return fPngPtr; }
     png_infop infoPtr() { return fInfoPtr; }
@@ -230,10 +230,7 @@ bool SkPngEncoderMgr::setHeader(const SkImageInfo& srcInfo, const SkPngEncoder::
     return true;
 }
 
-static transform_scanline_proc choose_proc(const SkImageInfo& info,
-                                           SkTransferFunctionBehavior unpremulBehavior) {
-    const bool isSRGBTransferFn =
-            (SkTransferFunctionBehavior::kRespect == unpremulBehavior) && info.gammaCloseToSRGB();
+static transform_scanline_proc choose_proc(const SkImageInfo& info) {
     switch (info.colorType()) {
         case kRGBA_8888_SkColorType:
             switch (info.alphaType()) {
@@ -242,8 +239,7 @@ static transform_scanline_proc choose_proc(const SkImageInfo& info,
                 case kUnpremul_SkAlphaType:
                     return transform_scanline_memcpy;
                 case kPremul_SkAlphaType:
-                    return isSRGBTransferFn ? transform_scanline_srgbA :
-                                              transform_scanline_rgbA;
+                    return transform_scanline_rgbA;
                 default:
                     SkASSERT(false);
                     return nullptr;
@@ -255,8 +251,7 @@ static transform_scanline_proc choose_proc(const SkImageInfo& info,
                 case kUnpremul_SkAlphaType:
                     return transform_scanline_BGRA;
                 case kPremul_SkAlphaType:
-                    return isSRGBTransferFn ? transform_scanline_sbgrA :
-                                              transform_scanline_bgrA;
+                    return transform_scanline_bgrA;
                 default:
                     SkASSERT(false);
                     return nullptr;
@@ -369,9 +364,8 @@ bool SkPngEncoderMgr::writeInfo(const SkImageInfo& srcInfo) {
     return true;
 }
 
-void SkPngEncoderMgr::chooseProc(const SkImageInfo& srcInfo,
-                                 SkTransferFunctionBehavior unpremulBehavior) {
-    fProc = choose_proc(srcInfo, unpremulBehavior);
+void SkPngEncoderMgr::chooseProc(const SkImageInfo& srcInfo) {
+    fProc = choose_proc(srcInfo);
 }
 
 std::unique_ptr<SkEncoder> SkPngEncoder::Make(SkWStream* dst, const SkPixmap& src,
@@ -397,7 +391,7 @@ std::unique_ptr<SkEncoder> SkPngEncoder::Make(SkWStream* dst, const SkPixmap& sr
         return nullptr;
     }
 
-    encoderMgr->chooseProc(src.info(), options.fUnpremulBehavior);
+    encoderMgr->chooseProc(src.info());
 
     return std::unique_ptr<SkPngEncoder>(new SkPngEncoder(std::move(encoderMgr), src));
 }
diff --git a/src/images/SkWebpEncoder.cpp b/src/images/SkWebpEncoder.cpp
index 2cb55d2f04..bda34dcb01 100644
--- a/src/images/SkWebpEncoder.cpp
+++ b/src/images/SkWebpEncoder.cpp
@@ -41,10 +41,7 @@ extern "C" {
 #include "webp/mux.h"
 }
 
-static transform_scanline_proc choose_proc(const SkImageInfo& info,
-                                           SkTransferFunctionBehavior unpremulBehavior) {
-    const bool isSRGBTransferFn =
-            (SkTransferFunctionBehavior::kRespect == unpremulBehavior) && info.gammaCloseToSRGB();
+static transform_scanline_proc choose_proc(const SkImageInfo& info) {
     switch (info.colorType()) {
         case kRGBA_8888_SkColorType:
             switch (info.alphaType()) {
@@ -53,8 +50,7 @@ static transform_scanline_proc choose_proc(const SkImageInfo& info,
                 case kUnpremul_SkAlphaType:
                     return transform_scanline_memcpy;
                 case kPremul_SkAlphaType:
-                    return isSRGBTransferFn ? transform_scanline_srgbA :
-                                              transform_scanline_rgbA;
+                    return transform_scanline_rgbA;
                 default:
                     return nullptr;
             }
@@ -65,8 +61,7 @@ static transform_scanline_proc choose_proc(const SkImageInfo& info,
                 case kUnpremul_SkAlphaType:
                     return transform_scanline_BGRA;
                 case kPremul_SkAlphaType:
-                    return isSRGBTransferFn ? transform_scanline_sbgrA :
-                                              transform_scanline_bgrA;
+                    return transform_scanline_bgrA;
                 default:
                     return nullptr;
             }
@@ -113,7 +108,7 @@ bool SkWebpEncoder::Encode(SkWStream* stream, const SkPixmap& pixmap, const Opti
         return false;
     }
 
-    const transform_scanline_proc proc = choose_proc(pixmap.info(), opts.fUnpremulBehavior);
+    const transform_scanline_proc proc = choose_proc(pixmap.info());
     if (!proc) {
         return false;
     }
diff --git a/src/shaders/SkPictureShader.cpp b/src/shaders/SkPictureShader.cpp
index 6ff4a0eb12..5549de240d 100644
--- a/src/shaders/SkPictureShader.cpp
+++ b/src/shaders/SkPictureShader.cpp
@@ -253,7 +253,7 @@ sk_sp<SkShader> SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix,
         }
 
         if (fColorSpace) {
-            tileImage = tileImage->makeColorSpace(fColorSpace, SkTransferFunctionBehavior::kIgnore);
+            tileImage = tileImage->makeColorSpace(fColorSpace);
         }
 
         tileShader = tileImage->makeShader(fTmx, fTmy);
diff --git a/tests/CodecTest.cpp b/tests/CodecTest.cpp
index 35cfb6c11b..179994be7c 100644
--- a/tests/CodecTest.cpp
+++ b/tests/CodecTest.cpp
@@ -1457,21 +1457,16 @@ DEF_TEST(Codec_InvalidAnimated, r) {
 }
 
 static void encode_format(SkDynamicMemoryWStream* stream, const SkPixmap& pixmap,
-                          SkTransferFunctionBehavior unpremulBehavior,
                           SkEncodedImageFormat format) {
-    SkPngEncoder::Options pngOptions;
-    SkWebpEncoder::Options webpOptions;
-    pngOptions.fUnpremulBehavior = unpremulBehavior;
-    webpOptions.fUnpremulBehavior = unpremulBehavior;
     switch (format) {
         case SkEncodedImageFormat::kPNG:
-            SkPngEncoder::Encode(stream, pixmap, pngOptions);
+            SkPngEncoder::Encode(stream, pixmap, SkPngEncoder::Options());
             break;
         case SkEncodedImageFormat::kJPEG:
             SkJpegEncoder::Encode(stream, pixmap, SkJpegEncoder::Options());
             break;
         case SkEncodedImageFormat::kWEBP:
-            SkWebpEncoder::Encode(stream, pixmap, webpOptions);
+            SkWebpEncoder::Encode(stream, pixmap, SkWebpEncoder::Options());
             break;
         default:
             SkASSERT(false);
@@ -1479,8 +1474,7 @@ static void encode_format(SkDynamicMemoryWStream* stream, const SkPixmap& pixmap
     }
 }
 
-static void test_encode_icc(skiatest::Reporter* r, SkEncodedImageFormat format,
-                            SkTransferFunctionBehavior unpremulBehavior) {
+static void test_encode_icc(skiatest::Reporter* r, SkEncodedImageFormat format) {
     // Test with sRGB color space.
     SkBitmap srgbBitmap;
     SkImageInfo srgbInfo = SkImageInfo::MakeS32(1, 1, kOpaque_SkAlphaType);
@@ -1489,7 +1483,7 @@ static void test_encode_icc(skiatest::Reporter* r, SkEncodedImageFormat format,
     SkPixmap pixmap;
     srgbBitmap.peekPixels(&pixmap);
     SkDynamicMemoryWStream srgbBuf;
-    encode_format(&srgbBuf, pixmap, unpremulBehavior, format);
+    encode_format(&srgbBuf, pixmap, format);
     sk_sp<SkData> srgbData = srgbBuf.detachAsData();
     std::unique_ptr<SkCodec> srgbCodec(SkCodec::MakeFromData(srgbData));
     REPORTER_ASSERT(r, srgbCodec->getInfo().colorSpace() == SkColorSpace::MakeSRGB().get());
@@ -1499,7 +1493,7 @@ static void test_encode_icc(skiatest::Reporter* r, SkEncodedImageFormat format,
     sk_sp<SkColorSpace> p3 = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
                                                    SkColorSpace::kDCIP3_D65_Gamut);
     pixmap.setColorSpace(p3);
-    encode_format(&p3Buf, pixmap, unpremulBehavior, format);
+    encode_format(&p3Buf, pixmap, format);
     sk_sp<SkData> p3Data = p3Buf.detachAsData();
     std::unique_ptr<SkCodec> p3Codec(SkCodec::MakeFromData(p3Data));
     REPORTER_ASSERT(r, p3Codec->getInfo().colorSpace()->gammaCloseToSRGB());
@@ -1518,12 +1512,9 @@ static void test_encode_icc(skiatest::Reporter* r, SkEncodedImageFormat format,
 }
 
 DEF_TEST(Codec_EncodeICC, r) {
-    test_encode_icc(r, SkEncodedImageFormat::kPNG, SkTransferFunctionBehavior::kRespect);
-    test_encode_icc(r, SkEncodedImageFormat::kJPEG, SkTransferFunctionBehavior::kRespect);
-    test_encode_icc(r, SkEncodedImageFormat::kWEBP, SkTransferFunctionBehavior::kRespect);
-    test_encode_icc(r, SkEncodedImageFormat::kPNG, SkTransferFunctionBehavior::kIgnore);
-    test_encode_icc(r, SkEncodedImageFormat::kJPEG, SkTransferFunctionBehavior::kIgnore);
-    test_encode_icc(r, SkEncodedImageFormat::kWEBP, SkTransferFunctionBehavior::kIgnore);
+    test_encode_icc(r, SkEncodedImageFormat::kPNG);
+    test_encode_icc(r, SkEncodedImageFormat::kJPEG);
+    test_encode_icc(r, SkEncodedImageFormat::kWEBP);
 }
 
 DEF_TEST(Codec_webp_rowsDecoded, r) {
diff --git a/tests/EncodeTest.cpp b/tests/EncodeTest.cpp
index 3c11663c98..30b53022df 100644
--- a/tests/EncodeTest.cpp
+++ b/tests/EncodeTest.cpp
@@ -336,5 +336,5 @@ DEF_TEST(Encode_WebpOptions, r) {
     SkImage::MakeFromEncoded(data3)->asLegacyBitmap(&bm3);
     REPORTER_ASSERT(r, almost_equals(bm0, bm1, 0));
     REPORTER_ASSERT(r, almost_equals(bm0, bm2, 90));
-    REPORTER_ASSERT(r, almost_equals(bm2, bm3, 45));
+    REPORTER_ASSERT(r, almost_equals(bm2, bm3, 50));
 }
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index 14df879174..6d2fb5976d 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -1206,7 +1206,7 @@ DEF_TEST(Image_makeColorSpace, r) {
     *srgbBitmap.getAddr32(0, 0) = SkSwizzle_RGBA_to_PMColor(0xFF604020);
     srgbBitmap.setImmutable();
     sk_sp<SkImage> srgbImage = SkImage::MakeFromBitmap(srgbBitmap);
-    sk_sp<SkImage> p3Image = srgbImage->makeColorSpace(p3, SkTransferFunctionBehavior::kIgnore);
+    sk_sp<SkImage> p3Image = srgbImage->makeColorSpace(p3);
     SkBitmap p3Bitmap;
     bool success = p3Image->asLegacyBitmap(&p3Bitmap);
 
@@ -1217,8 +1217,7 @@ DEF_TEST(Image_makeColorSpace, r) {
     REPORTER_ASSERT(r, almost_equal(0x40, SkGetPackedG32(*p3Bitmap.getAddr32(0, 0))));
     REPORTER_ASSERT(r, almost_equal(0x5E, SkGetPackedB32(*p3Bitmap.getAddr32(0, 0))));
 
-    sk_sp<SkImage> adobeImage = srgbImage->makeColorSpace(adobeGamut,
-                                                          SkTransferFunctionBehavior::kIgnore);
+    sk_sp<SkImage> adobeImage = srgbImage->makeColorSpace(adobeGamut);
     SkBitmap adobeBitmap;
     success = adobeImage->asLegacyBitmap(&adobeBitmap);
     REPORTER_ASSERT(r, success);
@@ -1227,7 +1226,7 @@ DEF_TEST(Image_makeColorSpace, r) {
     REPORTER_ASSERT(r, almost_equal(0x4C, SkGetPackedB32(*adobeBitmap.getAddr32(0, 0))));
 
     srgbImage = GetResourceAsImage("images/1x1.png");
-    p3Image = srgbImage->makeColorSpace(p3, SkTransferFunctionBehavior::kIgnore);
+    p3Image = srgbImage->makeColorSpace(p3);
     success = p3Image->asLegacyBitmap(&p3Bitmap);
     REPORTER_ASSERT(r, success);
     REPORTER_ASSERT(r, almost_equal(0x8B, SkGetPackedR32(*p3Bitmap.getAddr32(0, 0))));
diff --git a/tools/create_flutter_test_images.cpp b/tools/create_flutter_test_images.cpp
index 683c2fe34a..a3c0ada68c 100644
--- a/tools/create_flutter_test_images.cpp
+++ b/tools/create_flutter_test_images.cpp
@@ -51,7 +51,6 @@ int main(int argc, char** argv) {
     image->readPixels(src, 0, 0, SkImage::kDisallow_CachingHint);
     SkFILEWStream dst0("gbr.png");
     SkPngEncoder::Options opts;
-    opts.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore; // Does not matter for opaque src
     SkAssertResult(SkPngEncoder::Encode(&dst0, src, opts));
 
     // Encode an image with steep transfer function.
diff --git a/tools/skqp/gm_knowledge.cpp b/tools/skqp/gm_knowledge.cpp
index a2416c9dca..72dba2b4d4 100644
--- a/tools/skqp/gm_knowledge.cpp
+++ b/tools/skqp/gm_knowledge.cpp
@@ -119,9 +119,7 @@ static float set_error_code(gmkb::Error* error_out, gmkb::Error error) {
 
 static bool WritePixmapToFile(const SkPixmap& pixmap, const char* path) {
     SkFILEWStream wStream(path);
-    SkPngEncoder::Options options;
-    options.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore;
-    return wStream.isValid() && SkPngEncoder::Encode(&wStream, pixmap, options);
+    return wStream.isValid() && SkPngEncoder::Encode(&wStream, pixmap, SkPngEncoder::Options());
 }
 
 constexpr SkColorType kColorType = kRGBA_8888_SkColorType;