color: Towards ColorTransform optimizations and code generation

ui/gfx/color_transform_unittest.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 "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/color_space.h"
 #include "ui/gfx/color_transform.h"
 #include "ui/gfx/icc_profile.h"
 #include "ui/gfx/test/icc_profiles.h"
@@ skipping 66 matching lines @@
   EXPECT_NEAR(tmp.y(), 1.0f, 0.001f);
   EXPECT_NEAR(tmp.z(), 1.0f, 0.001f);
 
   // Test a blue color
   tmp = ColorTransform::TriStim(128.0f / 255.0f, 240.0f / 255.0f, 0.5f);
   t->transform(&tmp, 1);
   EXPECT_GT(tmp.z(), tmp.x());
   EXPECT_GT(tmp.z(), tmp.y());
 }
 
+TEST(SimpleColorSpace, SRGBFromICCAndNotICC) {
+  float kEpsilon = 0.001f;
+  ColorTransform::TriStim value_fromicc;
+  ColorTransform::TriStim value_default;
+
+  ICCProfile srgb_icc_profile = ICCProfileForTestingSRGB();
+  ColorSpace srgb_fromicc = srgb_icc_profile.GetColorSpace();
+  ColorSpace srgb_default = gfx::ColorSpace::CreateSRGB();
+  ColorSpace xyzd50 = gfx::ColorSpace::CreateXYZD50();
+
+  value_fromicc = value_default = ColorTransform::TriStim(0.1, 0.5, 0.9);
+
+  std::unique_ptr<ColorTransform> toxyzd50_fromicc(
+      ColorTransform::NewColorTransform(
+          srgb_fromicc, xyzd50, ColorTransform::Intent::INTENT_ABSOLUTE));
+  // This will have 1 step, namely, the QCMS transform.
+  EXPECT_EQ(toxyzd50_fromicc->NumberOfStepsForTesting(), 1u);
+  toxyzd50_fromicc->transform(&value_fromicc, 1);
+
+  std::unique_ptr<ColorTransform> toxyzd50_default(
+      ColorTransform::NewColorTransform(
+          srgb_default, xyzd50, ColorTransform::Intent::INTENT_ABSOLUTE));
+  // This will have a transfer function and then linear transform.
+  EXPECT_EQ(toxyzd50_default->NumberOfStepsForTesting(), 2u);
+  toxyzd50_default->transform(&value_default, 1);
+
+  EXPECT_NEAR(value_fromicc.x(), value_default.x(), kEpsilon);
+  EXPECT_NEAR(value_fromicc.y(), value_default.y(), kEpsilon);
+  EXPECT_NEAR(value_fromicc.z(), value_default.z(), kEpsilon);
+
+  value_fromicc = value_default = ColorTransform::TriStim(0.1, 0.5, 0.9);
+
+  std::unique_ptr<ColorTransform> fromxyzd50_fromicc(
+      ColorTransform::NewColorTransform(
+          xyzd50, srgb_fromicc, ColorTransform::Intent::INTENT_ABSOLUTE));
+  fromxyzd50_fromicc->transform(&value_fromicc, 1);
+
+  std::unique_ptr<ColorTransform> fromxyzd50_default(
+      ColorTransform::NewColorTransform(
+          xyzd50, srgb_default, ColorTransform::Intent::INTENT_ABSOLUTE));
+  fromxyzd50_default->transform(&value_default, 1);
+
+  EXPECT_NEAR(value_fromicc.x(), value_default.x(), kEpsilon);
+  EXPECT_NEAR(value_fromicc.y(), value_default.y(), kEpsilon);
+  EXPECT_NEAR(value_fromicc.z(), value_default.z(), kEpsilon);
+}
+
 TEST(SimpleColorSpace, BT709toSRGBICC) {
   ICCProfile srgb_icc = ICCProfileForTestingSRGB();
   ColorSpace bt709 = ColorSpace::CreateREC709();
   ColorSpace sRGB = srgb_icc.GetColorSpace();
   std::unique_ptr<ColorTransform> t(ColorTransform::NewColorTransform(
       bt709, sRGB, ColorTransform::Intent::INTENT_ABSOLUTE));
 
   ColorTransform::TriStim tmp(16.0f / 255.0f, 0.5f, 0.5f);
   t->transform(&tmp, 1);
   EXPECT_NEAR(tmp.x(), 0.0f, 0.001f);
@@ skipping 71 matching lines @@
   // Test a blue color
   tmp = ColorTransform::TriStim(128.0f / 255.0f, 240.0f / 255.0f, 0.5f);
   t->transform(&tmp, 1);
   EXPECT_GT(tmp.z(), tmp.x());
   EXPECT_GT(tmp.z(), tmp.y());
 }
 
 class TransferTest : public testing::TestWithParam<ColorSpace::TransferID> {};
 
 TEST_P(TransferTest, basicTest) {
+  gfx::ColorSpace space_with_transfer(ColorSpace::PrimaryID::BT709, GetParam(),
+                                      ColorSpace::MatrixID::RGB,
+                                      ColorSpace::RangeID::FULL);
+  gfx::ColorSpace space_linear(
+      ColorSpace::PrimaryID::BT709, ColorSpace::TransferID::LINEAR,
+      ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL);
+
+  std::unique_ptr<ColorTransform> to_linear(ColorTransform::NewColorTransform(
+      space_with_transfer, space_linear,
+      ColorTransform::Intent::INTENT_ABSOLUTE));
+
+  std::unique_ptr<ColorTransform> from_linear(ColorTransform::NewColorTransform(
+      space_linear, space_with_transfer,
+      ColorTransform::Intent::INTENT_ABSOLUTE));
+
+  // The transforms will ahve 1 or 0 steps (0 for linear).
+  size_t expected_steps = 1u;
+  if (GetParam() == ColorSpace::TransferID::LINEAR)
+    expected_steps = 0u;
+  EXPECT_EQ(to_linear->NumberOfStepsForTesting(), expected_steps);
+  EXPECT_EQ(from_linear->NumberOfStepsForTesting(), expected_steps);
+
   for (float x = 0.0f; x <= 1.0f; x += 1.0f / 128.0f) {
-    float linear = ColorTransform::ToLinearForTesting(GetParam(), x);
-    float x2 = ColorTransform::FromLinearForTesting(GetParam(), linear);
-    EXPECT_NEAR(x, x2, 0.001f);
+    ColorTransform::TriStim tristim(x, x, x);
+    to_linear->transform(&tristim, 1);
+    from_linear->transform(&tristim, 1);
+    EXPECT_NEAR(x, tristim.x(), 0.001f);
   }
 }
 
 INSTANTIATE_TEST_CASE_P(ColorSpace,
                         TransferTest,
                         testing::ValuesIn(all_transfers));
 
 typedef std::tr1::tuple<ColorSpace::PrimaryID,
                         ColorSpace::TransferID,
                         ColorSpace::MatrixID,
@@ skipping 58 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(
     C,
     ColorSpaceTest,
     testing::Combine(testing::ValuesIn(all_primaries),
                      testing::Values(ColorSpace::TransferID::BT709),
                      testing::ValuesIn(all_matrices),
                      testing::ValuesIn(all_ranges),
                      testing::ValuesIn(intents)));
 }  // namespace