color: Add support for shader generation

cc/output/program_binding.cc

 // Copyright 2011 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/program_binding.h"
 
 #include "base/trace_event/trace_event.h"
 #include "cc/output/geometry_binding.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "ui/gfx/color_transform.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 ProgramKey::ProgramKey() = default;
 ProgramKey::ProgramKey(const ProgramKey& other) = default;
 ProgramKey::~ProgramKey() = default;
 
 bool ProgramKey::operator==(const ProgramKey& other) const {
   return type_ == other.type_ && precision_ == other.precision_ &&
          sampler_ == other.sampler_ && blend_mode_ == other.blend_mode_ &&
          aa_mode_ == other.aa_mode_ && swizzle_mode_ == other.swizzle_mode_ &&
          is_opaque_ == other.is_opaque_ &&
          premultiplied_alpha_ == other.premultiplied_alpha_ &&
          has_background_color_ == other.has_background_color_ &&
          mask_mode_ == other.mask_mode_ &&
          mask_for_background_ == other.mask_for_background_ &&
          has_color_matrix_ == other.has_color_matrix_ &&
          yuv_alpha_texture_mode_ == other.yuv_alpha_texture_mode_ &&
          uv_texture_mode_ == other.uv_texture_mode_ &&
-         color_conversion_mode_ == other.color_conversion_mode_;
+         color_conversion_mode_ == other.color_conversion_mode_ &&
+         color_transform_ == other.color_transform_;
 }
 
 bool ProgramKey::operator!=(const ProgramKey& other) const {
   return !(*this == other);
 }
 
 // static
 ProgramKey ProgramKey::DebugBorder() {
   ProgramKey result;
   result.type_ = PROGRAM_TYPE_DEBUG_BORDER;
@@ skipping 78 matching lines @@
   result.sampler_ = sampler;
   result.yuv_alpha_texture_mode_ = yuv_alpha_texture_mode;
   DCHECK(yuv_alpha_texture_mode == YUV_NO_ALPHA_TEXTURE ||
          yuv_alpha_texture_mode == YUV_HAS_ALPHA_TEXTURE);
   result.uv_texture_mode_ = uv_texture_mode;
   DCHECK(uv_texture_mode == UV_TEXTURE_MODE_UV ||
          uv_texture_mode == UV_TEXTURE_MODE_U_V);
   return result;
 }
 
+void ProgramKey::SetColorTransform(const gfx::ColorTransform* transform) {
+  color_transform_ = nullptr;
+  if (transform->IsIdentity()) {
+    color_conversion_mode_ = COLOR_CONVERSION_MODE_NONE;
+  } else if (transform->CanGetShaderSource()) {
+    color_conversion_mode_ = COLOR_CONVERSION_MODE_SHADER;
+    color_transform_ = transform;
+  } else {
+    color_conversion_mode_ = COLOR_CONVERSION_MODE_LUT;

[hubbe, 2017/02/16 20:53:53]

Can we save the transform here too and use it to generate the LUT from inside
shader.cc. Seems like it would be more consistent with how the other two cases
are handled.

[ccameron, 2017/02/16 22:33:52]

I've updated the patch to use the ColorTransform in ColorLUTCache (instead of
re-computing it).

I'm leaving the ColorTransform out of the ProgramKey for LUT because the
generated program doesn't depend on it -- this way, we can re-use the same
program with different LUTs, rather than have to re-build the program for each
new color space pair.

+  }
+}
+
 ProgramBindingBase::ProgramBindingBase()
     : program_(0),
       vertex_shader_id_(0),
       fragment_shader_id_(0),
       initialized_(false) {}
 
 ProgramBindingBase::~ProgramBindingBase() {
   // If you hit these asserts, you initialized but forgot to call Cleanup().
   DCHECK(!program_);
   DCHECK(!vertex_shader_id_);
@@ skipping 111 matching lines @@
     context->DeleteShader(fragment_shader_id_);
     fragment_shader_id_ = 0;
   }
 }
 
 bool ProgramBindingBase::IsContextLost(GLES2Interface* context) {
   return context->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
 }
 
 }  // namespace cc