Revert of Use SkICC in gfx::ICCProfile and gfx::ColorSpace

ui/gfx/color_transform.cc

 // Copyright (c) 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/color_transform.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "ui/gfx/color_space.h"
 #include "ui/gfx/icc_profile.h"
 #include "ui/gfx/transform.h"
 #include "third_party/qcms/src/qcms.h"
 
 #ifndef THIS_MUST_BE_INCLUDED_AFTER_QCMS_H
 extern "C" {
 #include "third_party/qcms/src/chain.h"
 };
 #endif
 
 namespace gfx {
 
-float EvalSkTransferFn(const SkColorSpaceTransferFn& fn, float x) {
-  if (x < 0)
-    return 0;
-  if (x < fn.fD)
-    return fn.fC * x + fn.fF;
-  return powf(fn.fA * x + fn.fB, fn.fG) + fn.fE;
-}
-
 Transform Invert(const Transform& t) {
   Transform ret = t;
   if (!t.GetInverse(&ret)) {
     LOG(ERROR) << "Inverse should alsways be possible.";
   }
   return ret;
 }
 
-float FromLinear(ColorSpace::TransferID id, float v) {
+GFX_EXPORT Transform GetPrimaryMatrix(ColorSpace::PrimaryID id) {
+  SkColorSpacePrimaries primaries = {0};
+  switch (id) {
+    case ColorSpace::PrimaryID::CUSTOM:
+      NOTREACHED();
+
+    case ColorSpace::PrimaryID::RESERVED0:
+    case ColorSpace::PrimaryID::RESERVED:
+    case ColorSpace::PrimaryID::UNSPECIFIED:
+    case ColorSpace::PrimaryID::UNKNOWN:
+    case ColorSpace::PrimaryID::BT709:
+      // BT709 is our default case. Put it after the switch just
+      // in case we somehow get an id which is not listed in the switch.
+      // (We don't want to use "default", because we want the compiler
+      //  to tell us if we forgot some enum values.)
+      primaries.fRX = 0.640f;
+      primaries.fRY = 0.330f;
+      primaries.fGX = 0.300f;
+      primaries.fGY = 0.600f;
+      primaries.fBX = 0.150f;
+      primaries.fBY = 0.060f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::BT470M:
+      primaries.fRX = 0.67f;
+      primaries.fRY = 0.33f;
+      primaries.fGX = 0.21f;
+      primaries.fGY = 0.71f;
+      primaries.fBX = 0.14f;
+      primaries.fBY = 0.08f;
+      primaries.fWX = 0.31f;
+      primaries.fWY = 0.316f;
+      break;
+
+    case ColorSpace::PrimaryID::BT470BG:
+      primaries.fRX = 0.64f;
+      primaries.fRY = 0.33f;
+      primaries.fGX = 0.29f;
+      primaries.fGY = 0.60f;
+      primaries.fBX = 0.15f;
+      primaries.fBY = 0.06f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::SMPTE170M:
+    case ColorSpace::PrimaryID::SMPTE240M:
+      primaries.fRX = 0.630f;
+      primaries.fRY = 0.340f;
+      primaries.fGX = 0.310f;
+      primaries.fGY = 0.595f;
+      primaries.fBX = 0.155f;
+      primaries.fBY = 0.070f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::FILM:
+      primaries.fRX = 0.681f;
+      primaries.fRY = 0.319f;
+      primaries.fGX = 0.243f;
+      primaries.fGY = 0.692f;
+      primaries.fBX = 0.145f;
+      primaries.fBY = 0.049f;
+      primaries.fWX = 0.310f;
+      primaries.fWY = 0.136f;
+      break;
+
+    case ColorSpace::PrimaryID::BT2020:
+      primaries.fRX = 0.708f;
+      primaries.fRY = 0.292f;
+      primaries.fGX = 0.170f;
+      primaries.fGY = 0.797f;
+      primaries.fBX = 0.131f;
+      primaries.fBY = 0.046f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::SMPTEST428_1:
+      primaries.fRX = 1.0f;
+      primaries.fRY = 0.0f;
+      primaries.fGX = 0.0f;
+      primaries.fGY = 1.0f;
+      primaries.fBX = 0.0f;
+      primaries.fBY = 0.0f;
+      primaries.fWX = 1.0f / 3.0f;
+      primaries.fWY = 1.0f / 3.0f;
+      break;
+
+    case ColorSpace::PrimaryID::SMPTEST431_2:
+      primaries.fRX = 0.680f;
+      primaries.fRY = 0.320f;
+      primaries.fGX = 0.265f;
+      primaries.fGY = 0.690f;
+      primaries.fBX = 0.150f;
+      primaries.fBY = 0.060f;
+      primaries.fWX = 0.314f;
+      primaries.fWY = 0.351f;
+      break;
+
+    case ColorSpace::PrimaryID::SMPTEST432_1:
+      primaries.fRX = 0.680f;
+      primaries.fRY = 0.320f;
+      primaries.fGX = 0.265f;
+      primaries.fGY = 0.690f;
+      primaries.fBX = 0.150f;
+      primaries.fBY = 0.060f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::XYZ_D50:
+      primaries.fRX = 1.0f;
+      primaries.fRY = 0.0f;
+      primaries.fGX = 0.0f;
+      primaries.fGY = 1.0f;
+      primaries.fBX = 0.0f;
+      primaries.fBY = 0.0f;
+      primaries.fWX = 0.34567f;
+      primaries.fWY = 0.35850f;
+      break;
+  }
+
+  SkMatrix44 matrix;
+  primaries.toXYZD50(&matrix);
+  return Transform(matrix);
+}
+
+GFX_EXPORT float FromLinear(ColorSpace::TransferID id, float v) {
   switch (id) {
     case ColorSpace::TransferID::SMPTEST2084_NON_HDR:
       // Should already be handled.
+      NOTREACHED();
+    case ColorSpace::TransferID::CUSTOM:
+    // TODO(hubbe): Actually implement custom transfer functions.
+    case ColorSpace::TransferID::RESERVED0:
+    case ColorSpace::TransferID::RESERVED:
+    case ColorSpace::TransferID::UNSPECIFIED:
+    case ColorSpace::TransferID::UNKNOWN:
+    // All unknown values default to BT709
+
+    case ColorSpace::TransferID::BT709:
+    case ColorSpace::TransferID::SMPTE170M:
+    case ColorSpace::TransferID::BT2020_10:
+    case ColorSpace::TransferID::BT2020_12:
+      // BT709 is our "default" cause, so put the code after the switch
+      // to avoid "control reaches end of non-void function" errors.
       break;
 
+    case ColorSpace::TransferID::GAMMA22:
+      v = fmax(0.0f, v);
+      return powf(v, 1.0f / 2.2f);
+
+    case ColorSpace::TransferID::GAMMA28:
+      v = fmax(0.0f, v);
+      return powf(v, 1.0f / 2.8f);
+
+    case ColorSpace::TransferID::SMPTE240M: {
+      v = fmax(0.0f, v);
+      float a = 1.11157219592173128753f;
+      float b = 0.02282158552944503135f;
+      if (v <= b) {
+        return 4.0f * v;
+      } else {
+        return a * powf(v, 0.45f) - (a - 1.0f);
+      }
+    }
+
+    case ColorSpace::TransferID::LINEAR:
+      return v;
+
     case ColorSpace::TransferID::LOG:
       if (v < 0.01f)
         return 0.0f;
       return 1.0f + log(v) / log(10.0f) / 2.0f;
 
     case ColorSpace::TransferID::LOG_SQRT:
       if (v < sqrt(10.0f) / 1000.0f)
         return 0.0f;
       return 1.0f + log(v) / log(10.0f) / 2.5f;
 
@@ skipping 15 matching lines @@
       float l = 0.0045f;
       if (v < -l) {
         return -(a * powf(-4.0f * v, 0.45f) + (a - 1.0f)) / 4.0f;
       } else if (v <= b) {
         return 4.5f * v;
       } else {
         return a * powf(v, 0.45f) - (a - 1.0f);
       }
     }
 
+    case ColorSpace::TransferID::IEC61966_2_1: {  // SRGB
+      v = fmax(0.0f, v);
+      float a = 1.055f;
+      float b = 0.0031308f;
+      if (v < b) {
+        return 12.92f * v;
+      } else {
+        return a * powf(v, 1.0f / 2.4f) - (a - 1.0f);
+      }
+    }
     case ColorSpace::TransferID::SMPTEST2084: {
       // Go from scRGB levels to 0-1.
       v *= 80.0f / 10000.0f;
       v = fmax(0.0f, v);
       float m1 = (2610.0f / 4096.0f) / 4.0f;
       float m2 = (2523.0f / 4096.0f) * 128.0f;
       float c1 = 3424.0f / 4096.0f;
       float c2 = (2413.0f / 4096.0f) * 32.0f;
       float c3 = (2392.0f / 4096.0f) * 32.0f;
       return powf((c1 + c2 * powf(v, m1)) / (1.0f + c3 * powf(v, m1)), m2);
     }
 
+    case ColorSpace::TransferID::SMPTEST428_1:
+      v = fmax(0.0f, v);
+      return powf(48.0f * v + 52.37f, 1.0f / 2.6f);
+
     // Spec: http://www.arib.or.jp/english/html/overview/doc/2-STD-B67v1_0.pdf
     case ColorSpace::TransferID::ARIB_STD_B67: {
       const float a = 0.17883277f;
       const float b = 0.28466892f;
       const float c = 0.55991073f;
       v = fmax(0.0f, v);
       if (v <= 1)
         return 0.5f * sqrtf(v);
       else
         return a * log(v - b) + c;
     }
 
-    default:
-      // Handled by SkColorSpaceTransferFn.
-      break;
+    // Chrome-specific values below
+    case ColorSpace::TransferID::GAMMA24:
+      v = fmax(0.0f, v);
+      return powf(v, 1.0f / 2.4f);
   }
-  NOTREACHED();
-  return 0;
+
+  v = fmax(0.0f, v);
+  float a = 1.099296826809442f;
+  float b = 0.018053968510807f;
+  if (v <= b) {
+    return 4.5f * v;
+  } else {
+    return a * powf(v, 0.45f) - (a - 1.0f);
+  }
 }
 
-float ToLinear(ColorSpace::TransferID id, float v) {
+GFX_EXPORT float ToLinear(ColorSpace::TransferID id, float v) {
   switch (id) {
+    case ColorSpace::TransferID::CUSTOM:
+    // TODO(hubbe): Actually implement custom transfer functions.
+    case ColorSpace::TransferID::RESERVED0:
+    case ColorSpace::TransferID::RESERVED:
+    case ColorSpace::TransferID::UNSPECIFIED:
+    case ColorSpace::TransferID::UNKNOWN:
+    // All unknown values default to BT709
+
+    case ColorSpace::TransferID::BT709:
+    case ColorSpace::TransferID::SMPTE170M:
+    case ColorSpace::TransferID::BT2020_10:
+    case ColorSpace::TransferID::BT2020_12:
+      // BT709 is our "default" cause, so put the code after the switch
+      // to avoid "control reaches end of non-void function" errors.
+      break;
+
+    case ColorSpace::TransferID::GAMMA22:
+      v = fmax(0.0f, v);
+      return powf(v, 2.2f);
+
+    case ColorSpace::TransferID::GAMMA28:
+      v = fmax(0.0f, v);
+      return powf(v, 2.8f);
+
+    case ColorSpace::TransferID::SMPTE240M: {
+      v = fmax(0.0f, v);
+      float a = 1.11157219592173128753f;
+      float b = 0.02282158552944503135f;
+      if (v <= FromLinear(ColorSpace::TransferID::SMPTE240M, b)) {
+        return v / 4.0f;
+      } else {
+        return powf((v + a - 1.0f) / a, 1.0f / 0.45f);
+      }
+    }
+
+    case ColorSpace::TransferID::LINEAR:
+      return v;
+
     case ColorSpace::TransferID::LOG:
       if (v < 0.0f)
         return 0.0f;
       return powf(10.0f, (v - 1.0f) * 2.0f);
 
     case ColorSpace::TransferID::LOG_SQRT:
       if (v < 0.0f)
         return 0.0f;
       return powf(10.0f, (v - 1.0f) * 2.5f);
 
@@ skipping 15 matching lines @@
       float l = 0.0045f;
       if (v < FromLinear(ColorSpace::TransferID::BT1361_ECG, -l)) {
         return -powf((1.0f - a - v * 4.0f) / a, 1.0f / 0.45f) / 4.0f;
       } else if (v <= FromLinear(ColorSpace::TransferID::BT1361_ECG, b)) {
         return v / 4.5f;
       } else {
         return powf((v + a - 1.0f) / a, 1.0f / 0.45f);
       }
     }
 
+    case ColorSpace::TransferID::IEC61966_2_1: {  // SRGB
+      v = fmax(0.0f, v);
+      float a = 1.055f;
+      float b = 0.0031308f;
+      if (v < FromLinear(ColorSpace::TransferID::IEC61966_2_1, b)) {
+        return v / 12.92f;
+      } else {
+        return powf((v + a - 1.0f) / a, 2.4f);
+      }
+    }
+
     case ColorSpace::TransferID::SMPTEST2084: {
       v = fmax(0.0f, v);
       float m1 = (2610.0f / 4096.0f) / 4.0f;
       float m2 = (2523.0f / 4096.0f) * 128.0f;
       float c1 = 3424.0f / 4096.0f;
       float c2 = (2413.0f / 4096.0f) * 32.0f;
       float c3 = (2392.0f / 4096.0f) * 32.0f;
       v = powf(
           fmax(powf(v, 1.0f / m2) - c1, 0) / (c2 - c3 * powf(v, 1.0f / m2)),
           1.0f / m1);
       // This matches the scRGB definition that 1.0 means 80 nits.
       // TODO(hubbe): It would be *nice* if 1.0 meant more than that, but
       // that might be difficult to do right now.
       v *= 10000.0f / 80.0f;
       return v;
     }
 
+    case ColorSpace::TransferID::SMPTEST428_1:
+      return (powf(v, 2.6f) - 52.37f) / 48.0f;
+
+    // Chrome-specific values below
+    case ColorSpace::TransferID::GAMMA24:
+      v = fmax(0.0f, v);
+      return powf(v, 2.4f);
+
     case ColorSpace::TransferID::SMPTEST2084_NON_HDR:
       v = fmax(0.0f, v);
       return fmin(2.3f * pow(v, 2.8f), v / 5.0f + 0.8f);
 
     // Spec: http://www.arib.or.jp/english/html/overview/doc/2-STD-B67v1_0.pdf
     case ColorSpace::TransferID::ARIB_STD_B67: {
       v = fmax(0.0f, v);
       const float a = 0.17883277f;
       const float b = 0.28466892f;
       const float c = 0.55991073f;
       float v_ = 0.0f;
       if (v <= 0.5f) {
         v_ = (v * 2.0f) * (v * 2.0f);
       } else {
         v_ = exp((v - c) / a) + b;
       }
       return v_;
     }
+  }
 
-    default:
-      // Handled by SkColorSpaceTransferFn.
-      break;
+  v = fmax(0.0f, v);
+  float a = 1.099296826809442f;
+  float b = 0.018053968510807f;
+  if (v < FromLinear(ColorSpace::TransferID::BT709, b)) {
+    return v / 4.5f;
+  } else {
+    return powf((v + a - 1.0f) / a, 1.0f / 0.45f);
   }
-  NOTREACHED();
-  return 0;
 }
 
 GFX_EXPORT Transform GetTransferMatrix(ColorSpace::MatrixID id) {
   // Default values for BT709;
   float Kr = 0.2126f;
   float Kb = 0.0722f;
   switch (id) {
     case ColorSpace::MatrixID::RGB:
       return Transform();
 
@@ skipping 166 matching lines @@
     for (size_t i = 0; i < num; i++)
       matrix_.TransformPoint(colors + i);
   }
 
  private:
   Transform matrix_;
 };
 
 class ColorTransformFromLinear : public ColorTransformInternal {
  public:
-  explicit ColorTransformFromLinear(ColorSpace::TransferID transfer,
-                                    const SkColorSpaceTransferFn& fn,
-                                    bool fn_valid)
-      : transfer_(transfer), fn_(fn), fn_valid_(fn_valid) {}
+  explicit ColorTransformFromLinear(ColorSpace::TransferID transfer)
+      : transfer_(transfer) {}
   bool Prepend(ColorTransformInternal* prev) override {
     return prev->Join(*this);
   }
 
   bool IsNull() override { return transfer_ == ColorSpace::TransferID::LINEAR; }
 
   void transform(ColorTransform::TriStim* colors, size_t num) override {
-    if (fn_valid_) {
-      for (size_t i = 0; i < num; i++) {
-        colors[i].set_x(EvalSkTransferFn(fn_, colors[i].x()));
-        colors[i].set_y(EvalSkTransferFn(fn_, colors[i].y()));
-        colors[i].set_z(EvalSkTransferFn(fn_, colors[i].z()));
-      }
-    } else {
-      for (size_t i = 0; i < num; i++) {
-        colors[i].set_x(FromLinear(transfer_, colors[i].x()));
-        colors[i].set_y(FromLinear(transfer_, colors[i].y()));
-        colors[i].set_z(FromLinear(transfer_, colors[i].z()));
-      }
+    for (size_t i = 0; i < num; i++) {
+      colors[i].set_x(FromLinear(transfer_, colors[i].x()));
+      colors[i].set_y(FromLinear(transfer_, colors[i].y()));
+      colors[i].set_z(FromLinear(transfer_, colors[i].z()));
     }
   }
 
  private:
   friend class ColorTransformToLinear;
   ColorSpace::TransferID transfer_;
-  SkColorSpaceTransferFn fn_;
-  bool fn_valid_ = false;
 };
 
 class ColorTransformToLinear : public ColorTransformInternal {
  public:
-  explicit ColorTransformToLinear(ColorSpace::TransferID transfer,
-                                  const SkColorSpaceTransferFn& fn,
-                                  bool fn_valid)
-      : transfer_(transfer), fn_(fn), fn_valid_(fn_valid) {}
+  explicit ColorTransformToLinear(ColorSpace::TransferID transfer)
+      : transfer_(transfer) {}
 
   bool Prepend(ColorTransformInternal* prev) override {
     return prev->Join(*this);
   }
 
   static bool IsGamma22(ColorSpace::TransferID transfer) {
     switch (transfer) {
       // We don't need to check BT709 here because it's been translated into
       // SRGB in ColorSpaceToColorSpaceTransform::ColorSpaceToLinear below.
       case ColorSpace::TransferID::GAMMA22:
@@ skipping 15 matching lines @@
   }
 
   bool IsNull() override { return transfer_ == ColorSpace::TransferID::LINEAR; }
 
   // Assumes BT2020 primaries.
   static float Luma(const ColorTransform::TriStim& c) {
     return c.x() * 0.2627f + c.y() * 0.6780f + c.z() * 0.0593f;
   }
 
   void transform(ColorTransform::TriStim* colors, size_t num) override {
-    if (fn_valid_) {
-      for (size_t i = 0; i < num; i++) {
-        colors[i].set_x(EvalSkTransferFn(fn_, colors[i].x()));
-        colors[i].set_y(EvalSkTransferFn(fn_, colors[i].y()));
-        colors[i].set_z(EvalSkTransferFn(fn_, colors[i].z()));
-      }
-    } else if (transfer_ == ColorSpace::TransferID::SMPTEST2084_NON_HDR) {
+    if (transfer_ == ColorSpace::TransferID::SMPTEST2084_NON_HDR) {
       for (size_t i = 0; i < num; i++) {
         ColorTransform::TriStim ret(ToLinear(transfer_, colors[i].x()),
                                     ToLinear(transfer_, colors[i].y()),
                                     ToLinear(transfer_, colors[i].z()));
         if (Luma(ret) > 0.0) {
           ColorTransform::TriStim smpte2084(
               ToLinear(ColorSpace::TransferID::SMPTEST2084, colors[i].x()),
               ToLinear(ColorSpace::TransferID::SMPTEST2084, colors[i].y()),
               ToLinear(ColorSpace::TransferID::SMPTEST2084, colors[i].z()));
           smpte2084.Scale(Luma(ret) / Luma(smpte2084));
           ret = smpte2084;
         }
         colors[i] = ret;
       }
     } else {
       for (size_t i = 0; i < num; i++) {
         colors[i].set_x(ToLinear(transfer_, colors[i].x()));
         colors[i].set_y(ToLinear(transfer_, colors[i].y()));
         colors[i].set_z(ToLinear(transfer_, colors[i].z()));
       }
     }
   }
 
  private:
   ColorSpace::TransferID transfer_;
-  SkColorSpaceTransferFn fn_;
-  bool fn_valid_ = false;
 };
 
 // BT2020 Constant Luminance is different than most other
 // ways to encode RGB values as YUV. The basic idea is that
 // transfer functions are applied on the Y value instead of
 // on the RGB values. However, running the transfer function
 // on the U and V values doesn't make any sense since they
 // are centered at 0.5. To work around this, the transfer function
 // is applied to the Y, R and B values, and then the U and V
 // values are calculated from that.
@@ skipping 135 matching lines @@
   void disable_optimizations() { disable_optimizations_ = true; }
 
  private:
   bool disable_optimizations_ = false;
   std::vector<std::unique_ptr<ColorTransformInternal>> transforms_;
 };
 
 class ColorSpaceToColorSpaceTransform {
  public:
   static Transform GetPrimaryTransform(const ColorSpace& c) {
-    SkMatrix44 sk_matrix;
-    c.GetPrimaryMatrix(&sk_matrix);
-    return Transform(sk_matrix);
+    if (c.primaries_ == ColorSpace::PrimaryID::CUSTOM) {
+      return Transform(c.custom_primary_matrix_[0], c.custom_primary_matrix_[1],
+                       c.custom_primary_matrix_[2], c.custom_primary_matrix_[3],
+                       c.custom_primary_matrix_[4], c.custom_primary_matrix_[5],
+                       c.custom_primary_matrix_[6], c.custom_primary_matrix_[7],
+                       c.custom_primary_matrix_[8], c.custom_primary_matrix_[9],
+                       c.custom_primary_matrix_[10],
+                       c.custom_primary_matrix_[11], 0.0f, 0.0f, 0.0f, 1.0f);
+    } else {
+      return GetPrimaryMatrix(c.primaries_);
+    }
   }
 
   static void ColorSpaceToColorSpace(ColorSpace from,
                                      ColorSpace to,
                                      ColorTransform::Intent intent,
                                      TransformBuilder* builder) {
     if (intent == ColorTransform::Intent::INTENT_PERCEPTUAL) {
       switch (from.transfer_) {
         case ColorSpace::TransferID::UNSPECIFIED:
         case ColorSpace::TransferID::BT709:
@@ skipping 22 matching lines @@
             from.transfer_ = ColorSpace::TransferID::GAMMA24;
           }
           break;
 
         default:  // Do nothing
           break;
       }
 
       // TODO(hubbe): shrink gamuts here (never stretch gamuts)
     }
-
     builder->Append(base::MakeUnique<ColorTransformMatrix>(
         GetRangeAdjustMatrix(from.range_, from.matrix_)));
-
     builder->Append(base::MakeUnique<ColorTransformMatrix>(
         Invert(GetTransferMatrix(from.matrix_))));
-
-    SkColorSpaceTransferFn to_linear_fn;
-    bool to_linear_fn_valid = from.GetTransferFunction(&to_linear_fn);
-    builder->Append(base::MakeUnique<ColorTransformToLinear>(
-        from.transfer_, to_linear_fn, to_linear_fn_valid));
-
+    builder->Append(base::MakeUnique<ColorTransformToLinear>(from.transfer_));
     if (from.matrix_ == ColorSpace::MatrixID::BT2020_CL) {
       // BT2020 CL is a special case.
       builder->Append(base::MakeUnique<ColorTransformFromBT2020CL>());
     }
     builder->Append(
         base::MakeUnique<ColorTransformMatrix>(GetPrimaryTransform(from)));
 
     builder->Append(base::MakeUnique<ColorTransformMatrix>(
         Invert(GetPrimaryTransform(to))));
     if (to.matrix_ == ColorSpace::MatrixID::BT2020_CL) {
       // BT2020 CL is a special case.
       builder->Append(base::MakeUnique<ColorTransformToBT2020CL>());
     }
 
-    SkColorSpaceTransferFn from_linear_fn;
-    bool from_linear_fn_valid = to.GetInverseTransferFunction(&from_linear_fn);
-    builder->Append(base::MakeUnique<ColorTransformFromLinear>(
-        to.transfer_, from_linear_fn, from_linear_fn_valid));
-
+    builder->Append(base::MakeUnique<ColorTransformFromLinear>(to.transfer_));
     builder->Append(
         base::MakeUnique<ColorTransformMatrix>(GetTransferMatrix(to.matrix_)));
-
     builder->Append(base::MakeUnique<ColorTransformMatrix>(
         Invert(GetRangeAdjustMatrix(to.range_, to.matrix_))));
   }
 };
 
 class QCMSColorTransform : public ColorTransformInternal {
  public:
   // Takes ownership of the profiles
   QCMSColorTransform(qcms_profile* from, qcms_profile* to)
       : from_(from), to_(to) {}
@@ skipping 75 matching lines @@
       from_profile ? ColorSpace::CreateXYZD50() : from,
       to_profile ? ColorSpace::CreateXYZD50() : to, intent, &builder);
   if (to_profile) {
     builder.Append(std::unique_ptr<ColorTransformInternal>(
         new QCMSColorTransform(GetXYZD50Profile(), to_profile)));
   }
 
   return builder.GetTransform();
 }
 
-// static
-float ColorTransform::ToLinearForTesting(ColorSpace::TransferID transfer,
-                                         float v) {
-  ColorSpace space(ColorSpace::PrimaryID::BT709, transfer,
-                   ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL);
-  SkColorSpaceTransferFn to_linear_fn;
-  bool to_linear_fn_valid = space.GetTransferFunction(&to_linear_fn);
-  ColorTransformToLinear to_linear_transform(transfer, to_linear_fn,
-                                             to_linear_fn_valid);
-  TriStim color(v, v, v);
-  to_linear_transform.transform(&color, 1);
-  return color.x();
-}
-
-// static
-float ColorTransform::FromLinearForTesting(ColorSpace::TransferID transfer,
-                                           float v) {
-  ColorSpace space(ColorSpace::PrimaryID::BT709, transfer,
-                   ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL);
-  SkColorSpaceTransferFn from_linear_fn;
-  bool from_linear_fn_valid = space.GetInverseTransferFunction(&from_linear_fn);
-
-  ColorTransformFromLinear from_linear_transform(transfer, from_linear_fn,
-                                                 from_linear_fn_valid);
-  TriStim color(v, v, v);
-  from_linear_transform.transform(&color, 1);
-  return color.x();
-}
-
 }  // namespace gfx