Blend TextureLayer background-color at draw time.

cc/output/software_renderer.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/software_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
@@ skipping 334 matching lines @@
 
   // TODO(skaslev): Add support for non-premultiplied alpha.
   ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
                                                 quad->resource_id);
   const SkBitmap* bitmap = lock.sk_bitmap();
   gfx::RectF uv_rect = gfx::ScaleRect(gfx::BoundingRect(quad->uv_top_left,
                                                         quad->uv_bottom_right),
                                       bitmap->width(),
                                       bitmap->height());
   SkRect sk_uv_rect = gfx::RectFToSkRect(uv_rect);
+  SkRect quad_rect = gfx::RectFToSkRect(QuadVertexRect());
+
   if (quad->flipped)
     current_canvas_->scale(1, -1);
-  current_canvas_->drawBitmapRectToRect(*bitmap, &sk_uv_rect,
-                                        gfx::RectFToSkRect(QuadVertexRect()),
+
+  bool blend_background = (SkColorGetA(quad->background_color) != 0) &&
+                          !bitmap->isOpaque(); 
+  bool needs_layer = blend_background && (current_paint_.getAlpha() != 0xFF);

[alokp, 2013/07/09 00:08:06]

reed@: Is there a paint mode in skia that will avoid having to create this
offscreen buffer?

We need to blend a bitmap over a solid color; blend the result with a global
alpha.

+  if (needs_layer) {
+    current_canvas_->saveLayerAlpha(&quad_rect, current_paint_.getAlpha());
+    current_paint_.setAlpha(0xFF);
+  }
+  if (blend_background) {
+    SkPaint background_paint;
+    background_paint.setColor(quad->background_color);
+    current_canvas_->drawRect(quad_rect, background_paint);
+  }
+
+  current_canvas_->drawBitmapRectToRect(*bitmap,
+                                        &sk_uv_rect,
+                                        quad_rect,
                                         &current_paint_);
+
+  if (needs_layer)
+    current_canvas_->restore();
 }
 
 void SoftwareRenderer::DrawTileQuad(const DrawingFrame* frame,
                                     const TileDrawQuad* quad) {
   DCHECK(!output_surface_->ForcedDrawToSoftwareDevice());
   DCHECK(IsSoftwareResource(quad->resource_id));
   ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
                                                 quad->resource_id);
 
   SkRect uv_rect = gfx::RectFToSkRect(quad->tex_coord_rect);
@@ skipping 118 matching lines @@
   visible_ = visible;
 }
 
 void SoftwareRenderer::SetDiscardBackBufferWhenNotVisible(bool discard) {
   // TODO(piman, skaslev): Can we release the backbuffer? We don't currently
   // receive memory policy yet anyway.
   NOTIMPLEMENTED();
 }
 
 }  // namespace cc