Blend TextureLayer background-color at draw time.

cc/output/gl_renderer.cc

 // Copyright 2010 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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 80 matching lines @@
   gfx::PointF uv0 = quad->uv_top_left;
   gfx::PointF uv1 = quad->uv_bottom_right;
   Float4 xform = { { uv0.x(), uv0.y(), uv1.x() - uv0.x(), uv1.y() - uv0.y() } };
   if (quad->flipped) {
     xform.data[1] = 1.0f - xform.data[1];
     xform.data[3] = -xform.data[3];
   }
   return xform;
 }
 
+Float4 PremultipliedColor(SkColor color) {
+  const float factor = 1.0f / 255.0f;
+  const float alpha = SkColorGetA(color) * factor;
+
+  Float4 result = { {
+      SkColorGetR(color) * factor * alpha,
+      SkColorGetG(color) * factor * alpha,
+      SkColorGetB(color) * factor * alpha,
+      alpha
+  } };
+  return result;
+}
+
 // Smallest unit that impact anti-aliasing output. We use this to
 // determine when anti-aliasing is unnecessary.
 const float kAntiAliasingEpsilon = 1.0f / 1024.0f;
 
 }  // anonymous namespace
 
 struct GLRenderer::PendingAsyncReadPixels {
   PendingAsyncReadPixels() : buffer(0) {}
 
   scoped_ptr<CopyOutputRequest> copy_request;
@@ skipping 1533 matching lines @@
   DrawContentQuad(frame, quad, on_demand_tile_raster_resource_id_);
 }
 
 struct TextureProgramBinding {
   template <class Program>
   void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
     DCHECK(program && (program->initialized() || context->isContextLost()));
     program_id = program->program();
     sampler_location = program->fragment_shader().sampler_location();
     matrix_location = program->vertex_shader().matrix_location();
-    alpha_location = program->fragment_shader().alpha_location();
+    background_color_location =
+        program->fragment_shader().background_color_location();
   }
   int program_id;
   int sampler_location;
   int matrix_location;
-  int alpha_location;
+  int background_color_location;
 };
 
 struct TexTransformTextureProgramBinding : TextureProgramBinding {
   template <class Program>
   void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
     TextureProgramBinding::Set(program, context);
     tex_transform_location = program->vertex_shader().tex_transform_location();
     vertex_opacity_location =
         program->vertex_shader().vertex_opacity_location();
   }
@@ skipping 34 matching lines @@
           static_cast<int>(draw_cache_.matrix_location),
           static_cast<int>(draw_cache_.matrix_data.size()),
           false,
           reinterpret_cast<float*>(&draw_cache_.matrix_data.front())));
   GLC(context_,
       context_->uniform4fv(
           static_cast<int>(draw_cache_.uv_xform_location),
           static_cast<int>(draw_cache_.uv_xform_data.size()),
           reinterpret_cast<float*>(&draw_cache_.uv_xform_data.front())));
   GLC(context_,
+      context_->uniform4fv(
+          static_cast<int>(draw_cache_.background_color_location),
+          static_cast<int>(draw_cache_.background_color_data.size()),
+          reinterpret_cast<float*>(
+              &draw_cache_.background_color_data.front())));
+  GLC(context_,
       context_->uniform1fv(
           static_cast<int>(draw_cache_.vertex_opacity_location),
           static_cast<int>(draw_cache_.vertex_opacity_data.size()),
           static_cast<float*>(&draw_cache_.vertex_opacity_data.front())));
 
   // Draw the quads!
   GLC(context_,
       context_->drawElements(GL_TRIANGLES,
                              6 * draw_cache_.matrix_data.size(),
                              GL_UNSIGNED_SHORT,
                              0));
 
   // Clear the cache.
   draw_cache_.program_id = 0;
   draw_cache_.uv_xform_data.resize(0);
+  draw_cache_.background_color_data.resize(0);
   draw_cache_.vertex_opacity_data.resize(0);
   draw_cache_.matrix_data.resize(0);
 }
 
 void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
                                     const TextureDrawQuad* quad) {
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       context_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
@@ skipping 11 matching lines @@
   if (draw_cache_.program_id != binding.program_id ||
       draw_cache_.resource_id != resource_id ||
       draw_cache_.needs_blending != quad->ShouldDrawWithBlending() ||
       draw_cache_.matrix_data.size() >= 8) {
     FlushTextureQuadCache();
     draw_cache_.program_id = binding.program_id;
     draw_cache_.resource_id = resource_id;
     draw_cache_.needs_blending = quad->ShouldDrawWithBlending();
 
     draw_cache_.uv_xform_location = binding.tex_transform_location;
+    draw_cache_.background_color_location = binding.background_color_location;
     draw_cache_.vertex_opacity_location = binding.vertex_opacity_location;
     draw_cache_.matrix_location = binding.matrix_location;
     draw_cache_.sampler_location = binding.sampler_location;
   }
 
   // Generate the uv-transform
   draw_cache_.uv_xform_data.push_back(UVTransform(quad));
 
+  draw_cache_.background_color_data.push_back(

[enne (OOO), 2013/07/02 01:27:22]

I don't think the draw cache should support per-quad background color.  The
texture cache feature is primarily for the nine patch layer on Android.  I think
you could get away with just a single uniform, and if the background color
changes, then just flush the cache.

[alokp, 2013/07/02 22:03:54]

Done.

+      PremultipliedColor(quad->background_color));
+
   // Generate the vertex opacity
   const float opacity = quad->opacity();
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[0] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[1] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[2] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[3] * opacity);
 
   // Generate the transform matrix
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
@@ skipping 20 matching lines @@
   SetUseProgram(binding.program_id);
   GLC(Context(), Context()->uniform1i(binding.sampler_location, 0));
   Float4 uv_xform = UVTransform(quad);
   GLC(Context(),
       Context()->uniform4f(binding.tex_transform_location,
                            uv_xform.data[0],
                            uv_xform.data[1],
                            uv_xform.data[2],
                            uv_xform.data[3]));
 
+  Float4 background_color = PremultipliedColor(quad->background_color);
+  GLC(Context(),
+      Context()->uniform4fv(
+          binding.background_color_location, 4, background_color.data));
+
   GLC(Context(),
       Context()->uniform1fv(
           binding.vertex_opacity_location, 4, quad->vertex_opacity));
 
   ResourceProvider::ScopedSamplerGL quad_resource_lock(
       resource_provider_, quad->resource_id, GL_TEXTURE_2D, GL_LINEAR);
 
   DrawQuadGeometry(
       frame, quad->quadTransform(), quad->rect, binding.matrix_location);
 }
@@ skipping 1191 matching lines @@
   std::string unique_context_name = base::StringPrintf(
       "%s-Offscreen-%p",
       Settings().compositor_name.c_str(),
       context_);
   resource_provider()->offscreen_context_provider()->Context3d()->
     pushGroupMarkerEXT(unique_context_name.c_str());
 }
 
 
 }  // namespace cc