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

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"
 #include "ui/gfx/transform.h"
 
 namespace gfx {
 
 // Internal functions, exposted for testing.
+GFX_EXPORT Transform GetPrimaryMatrix(ColorSpace::PrimaryID id);
 GFX_EXPORT Transform GetTransferMatrix(ColorSpace::MatrixID id);
+GFX_EXPORT float ToLinear(ColorSpace::TransferID id, float v);
+GFX_EXPORT float FromLinear(ColorSpace::TransferID id, float v);
 
 ColorSpace::PrimaryID all_primaries[] = {
     ColorSpace::PrimaryID::BT709,        ColorSpace::PrimaryID::BT470M,
     ColorSpace::PrimaryID::BT470BG,      ColorSpace::PrimaryID::SMPTE170M,
     ColorSpace::PrimaryID::SMPTE240M,    ColorSpace::PrimaryID::FILM,
     ColorSpace::PrimaryID::BT2020,       ColorSpace::PrimaryID::SMPTEST428_1,
     ColorSpace::PrimaryID::SMPTEST431_2, ColorSpace::PrimaryID::SMPTEST432_1,
 };
 
 ColorSpace::TransferID all_transfers[] = {
@@ skipping 80 matching lines @@
   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, GetColorSpace) {
   ICCProfile srgb_icc = ICCProfileForTestingSRGB();
   ColorSpace sRGB = srgb_icc.GetColorSpace();
   ColorSpace sRGB2 = sRGB;
-  const float kEpsilon = 1.5f / 255.f;
 
   // Prevent sRGB2 from using a cached ICC profile.
   sRGB2.icc_profile_id_ = 0;
 
   std::unique_ptr<ColorTransform> t(ColorTransform::NewColorTransform(
       sRGB, sRGB2, ColorTransform::Intent::INTENT_ABSOLUTE));
 
   ColorTransform::TriStim tmp(1.0f, 1.0f, 1.0f);
   t->transform(&tmp, 1);
-  EXPECT_NEAR(tmp.x(), 1.0f, kEpsilon);
-  EXPECT_NEAR(tmp.y(), 1.0f, kEpsilon);
-  EXPECT_NEAR(tmp.z(), 1.0f, kEpsilon);
+  EXPECT_NEAR(tmp.x(), 1.0f, 0.001f);
+  EXPECT_NEAR(tmp.y(), 1.0f, 0.001f);
+  EXPECT_NEAR(tmp.z(), 1.0f, 0.001f);
 
   tmp = ColorTransform::TriStim(1.0f, 0.0f, 0.0f);
   t->transform(&tmp, 1);
-  EXPECT_NEAR(tmp.x(), 1.0f, kEpsilon);
-  EXPECT_NEAR(tmp.y(), 0.0f, kEpsilon);
-  EXPECT_NEAR(tmp.z(), 0.0f, kEpsilon);
+  EXPECT_NEAR(tmp.x(), 1.0f, 0.001f);
+  EXPECT_NEAR(tmp.y(), 0.0f, 0.001f);
+  EXPECT_NEAR(tmp.z(), 0.0f, 0.001f);
 
   tmp = ColorTransform::TriStim(0.0f, 1.0f, 0.0f);
   t->transform(&tmp, 1);
-  EXPECT_NEAR(tmp.x(), 0.0f, kEpsilon);
-  EXPECT_NEAR(tmp.y(), 1.0f, kEpsilon);
-  EXPECT_NEAR(tmp.z(), 0.0f, kEpsilon);
+  EXPECT_NEAR(tmp.x(), 0.0f, 0.001f);
+  EXPECT_NEAR(tmp.y(), 1.0f, 0.001f);
+  EXPECT_NEAR(tmp.z(), 0.0f, 0.001f);
 
   tmp = ColorTransform::TriStim(0.0f, 0.0f, 1.0f);
   t->transform(&tmp, 1);
-  EXPECT_NEAR(tmp.x(), 0.0f, kEpsilon);
-  EXPECT_NEAR(tmp.y(), 0.0f, kEpsilon);
-  EXPECT_NEAR(tmp.z(), 1.0f, kEpsilon);
+  EXPECT_NEAR(tmp.x(), 0.0f, 0.001f);
+  EXPECT_NEAR(tmp.y(), 0.0f, 0.001f);
+  EXPECT_NEAR(tmp.z(), 1.0f, 0.001f);
 }
 
 TEST(SimpleColorSpace, UnknownToSRGB) {
   ColorSpace unknown;
   ColorSpace sRGB = ColorSpace::CreateSRGB();
   std::unique_ptr<ColorTransform> t(ColorTransform::NewColorTransform(
       unknown, sRGB, ColorTransform::Intent::INTENT_PERCEPTUAL));
 
   ColorTransform::TriStim tmp(16.0f / 255.0f, 0.5f, 0.5f);
   t->transform(&tmp, 1);
   EXPECT_NEAR(tmp.x(), 0.0f, 0.001f);
   EXPECT_NEAR(tmp.y(), 0.0f, 0.001f);
   EXPECT_NEAR(tmp.z(), 0.0f, 0.001f);
 
   tmp = ColorTransform::TriStim(235.0f / 255.0f, 0.5f, 0.5f);
   t->transform(&tmp, 1);
   EXPECT_NEAR(tmp.x(), 1.0f, 0.001f);
   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());
 }
 
+class PrimaryTest : public testing::TestWithParam<ColorSpace::PrimaryID> {};
+
+TEST_P(PrimaryTest, checkInvertible) {
+  EXPECT_EQ(GetPrimaryMatrix(GetParam()).matrix().get(3, 3), 1.0f);
+  // Check that all primary matrices are invertable.
+  EXPECT_TRUE(GetPrimaryMatrix(GetParam()).IsInvertible());
+}
+
+INSTANTIATE_TEST_CASE_P(ColorSpace,
+                        PrimaryTest,
+                        testing::ValuesIn(all_primaries));
+
 class MatrixTest : public testing::TestWithParam<ColorSpace::MatrixID> {};
 
 TEST_P(MatrixTest, checkInvertible) {
   EXPECT_EQ(GetTransferMatrix(GetParam()).matrix().get(3, 3), 1.0f);
   // Check that all transfer matrices are invertable.
   EXPECT_TRUE(GetTransferMatrix(GetParam()).IsInvertible());
 };
 
 INSTANTIATE_TEST_CASE_P(ColorSpace,
                         MatrixTest,
                         testing::ValuesIn(all_matrices));
 
 class TransferTest : public testing::TestWithParam<ColorSpace::TransferID> {};
 
 TEST_P(TransferTest, basicTest) {
   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);
+    float linear = ToLinear(GetParam(), x);
+    float x2 = FromLinear(GetParam(), linear);
     EXPECT_NEAR(x, x2, 0.001f);
   }
 }
 
 INSTANTIATE_TEST_CASE_P(ColorSpace,
                         TransferTest,
                         testing::ValuesIn(all_transfers));
 
 typedef std::tr1::tuple<ColorSpace::PrimaryID,
                         ColorSpace::TransferID,
@@ skipping 59 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