color: Add analytic transfer functions in shaders

cc/output/gl_renderer_unittest.cc

 // Copyright 2012 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 "cc/output/gl_renderer.h"
 
 #include <stdint.h>
 
 #include <set>
 #include <vector>
@@ skipping 116 matching lines @@
     ASSERT_FALSE(renderer()->IsContextLost());
   }
 
   void TearDown() override {
     GLRendererPixelTest::TearDown();
     ASSERT_FALSE(renderer()->IsContextLost());
   }
 
   void TestShader(const ProgramKey& program_key) {
     renderer()->SetCurrentFrameForTesting(GLRenderer::DrawingFrame());
-    const size_t kNumSrcColorSpaces = 3;
+    const size_t kNumSrcColorSpaces = 4;
     gfx::ColorSpace src_color_spaces[kNumSrcColorSpaces] = {
         gfx::ColorSpace(), gfx::ColorSpace::CreateSRGB(),
         gfx::ColorSpace::CreateREC709(),
     };
     const size_t kNumDstColorSpaces = 3;
     gfx::ColorSpace dst_color_spaces[kNumDstColorSpaces] = {
         gfx::ColorSpace(), gfx::ColorSpace::CreateSRGB(),
         gfx::ColorSpace::CreateSCRGBLinear(),
     };
     for (size_t i = 0; i < kNumDstColorSpaces; ++i) {
       for (size_t j = 0; j < kNumSrcColorSpaces; ++j) {
         renderer()->SetUseProgram(program_key, src_color_spaces[j],
                                   dst_color_spaces[i]);
         EXPECT_TRUE(renderer()->current_program_->initialized());
       }
     }
   }
 
   void TestBasicShaders() {
     TestShader(ProgramKey::DebugBorder());
     TestShader(ProgramKey::SolidColor(NO_AA));
     TestShader(ProgramKey::SolidColor(USE_AA));
   }
 
+  void TestColorShaders() {
+    const size_t kNumTransferFns = 7;
+    SkColorSpaceTransferFn transfer_fns[kNumTransferFns] = {
+        // The identity.
+        {1.f, 1.f, 0.f, 1.f, 0.f, 0.f, 0.f},
+        // The identity, with an if statement.
+        {1.f, 1.f, 0.f, 1.f, 0.5f, 0.f, 0.f},
+        // Just the power function.
+        {1.1f, 1.f, 0.f, 1.f, 0.f, 0.f, 0.f},
+        // Everything but the power function, nonlinear only.
+        {1.f, 0.9f, 0.1f, 0.9f, 0.f, 0.1f, 0.1f},
+        // Everything, nonlinear only.
+        {1.1f, 0.9f, 0.1f, 0.9f, 0.f, 0.1f, 0.1f},
+        // Everything but the power function.
+        {1.f, 0.9f, 0.1f, 0.9f, 0.5f, 0.1f, 0.1f},
+        // Everything.
+        {1.1f, 0.9f, 0.1f, 0.9f, 0.5f, 0.1f, 0.1f},
+    };
+
+    for (size_t i = 0; i < kNumTransferFns; ++i) {
+      SkMatrix44 primaries;
+      gfx::ColorSpace::CreateSRGB().GetPrimaryMatrix(&primaries);
+      gfx::ColorSpace src =
+          gfx::ColorSpace::CreateCustom(primaries, transfer_fns[i]);
+
+      renderer()->SetCurrentFrameForTesting(GLRenderer::DrawingFrame());
+      renderer()->SetUseProgram(ProgramKey::SolidColor(NO_AA), src,
+                                gfx::ColorSpace::CreateXYZD50());
+      EXPECT_TRUE(renderer()->current_program_->initialized());
+    }
+  }
+
   void TestShadersWithPrecision(TexCoordPrecision precision) {
     // This program uses external textures and sampler, so it won't compile
     // everywhere.
     if (context_provider()->ContextCapabilities().egl_image_external) {
       TestShader(ProgramKey::VideoStream(precision));
     }
   }
 
   void TestShadersWithPrecisionAndBlend(TexCoordPrecision precision,
                                         BlendMode blend_mode) {
@@ skipping 89 matching lines @@
 static const SamplerType kSamplerList[] = {
     SAMPLER_TYPE_2D,
     SAMPLER_TYPE_2D_RECT,
     SAMPLER_TYPE_EXTERNAL_OES,
 };
 
 TEST_F(GLRendererShaderPixelTest, BasicShadersCompile) {
   TestBasicShaders();
 }
 
+TEST_F(GLRendererShaderPixelTest, TestColorShadersCompile) {
+  TestColorShaders();
+}
+
 class PrecisionShaderPixelTest
     : public GLRendererShaderPixelTest,
       public ::testing::WithParamInterface<TexCoordPrecision> {};
 
 TEST_P(PrecisionShaderPixelTest, ShadersCompile) {
   TestShadersWithPrecision(GetParam());
 }
 
 INSTANTIATE_TEST_CASE_P(PrecisionShadersCompile,
                         PrecisionShaderPixelTest,
@@ skipping 1705 matching lines @@
   renderer_->SetVisible(true);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 
   EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(true));
   renderer_->SetVisible(false);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 }
 
 }  // namespace
 }  // namespace cc