Adding support for blending in cc::SoftwareRenderer

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 492 matching lines @@
   skia::RefPtr<SkShader> shader;
   if (filter_bitmap.isNull()) {
     shader = skia::AdoptRef(SkShader::CreateBitmapShader(
         *content, content_tile_mode, content_tile_mode, &content_mat));
   } else {
     shader = skia::AdoptRef(SkShader::CreateBitmapShader(
         filter_bitmap, content_tile_mode, content_tile_mode, &content_mat));
   }
   current_paint_.setShader(shader.get());
 
+  if (quad->shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode)
+    current_paint_.setXfermodeMode(quad->shared_quad_state->blend_mode);

[Erik Dahlström (inactive), 2014/09/05 09:19:23]

It's a little confusing that xfermode is set in DoDrawQuad above too, with this
overriding it (could lead to bugs if code is moved around).

[rosca, 2014/09/05 09:35:31]

Indeed, DoDrawQuad would be the right place where we should set the xfermode,
but for now we should only apply blend mode for render passes. Blend mode is
also set on the owning layer of the render pass and we should not apply it
there.
I will move it to DoDrawQuad, but I should remove blend modes for the quads of
the owning layers first.

[enne (OOO), 2014/09/05 17:49:08]

It seems like maybe the owning layer shouldn't have blend_mode set for its
shared quad state, then.

[rosca, 2014/09/05 20:52:27]

I'll do it with another patch, including some unit tests. I think it's suitable
to add a blend_mode field in draw_properties, which could be different from
LayerType::blend_mode.

[enne (OOO), 2014/09/05 21:03:04]

DrawProperties doesn't seem like the right place for this.  Those are all
computed properties based on tree hierarchies.

Can you help me understand why the blend mode on SharedQuadState is not
sufficient? The owning layer's SharedQuadState for drawing as itself and the
render pass's SharedQuadState for representing a contributing render surfaces
when it draws are not the same.  Could you not just set blend mode properly on
the right SharedQuadStates and then have DoDrawQuad always read it and set it
from there?

[rosca, 2014/09/06 00:25:47]

Now, all the blending layers get their own render surfaces, so we need to set
blend_mode only on the render pass's SharedQuadState(SQS). What happens in the
code is that we set blend_mode on render surfaces' SQS and on each of the
layers' SQS, even if the latter is not used at the moment.
I think that we should keep setting blend mode on layer's SQS, as we are going
to support blending for layers without separate rendering surfaces. The only
case where we should avoid setting blend_mode in layer's SQS is when the layer
has its own rendering surface which will become responsible for blending the
entire subtree as a group.

In this context blend_mode looks like a property based on tree hierarchy, this
is why I was thinking off adding it to draw_properties. However, I can compute
the blend mode for layers right before calling shared_quad_state->SetAll(), by
looking for the rendering surface existence. Do you think this would be better?

I uploaded my changes with draw_properties here:
https://codereview.chromium.org/549683002.

+
   if (quad->mask_resource_id) {
     ResourceProvider::ScopedReadLockSoftware mask_lock(resource_provider_,
                                                        quad->mask_resource_id);
     if (!lock.valid())
       return;
     SkShader::TileMode mask_tile_mode = WrapModeToTileMode(
         mask_lock.wrap_mode());
 
     const SkBitmap* mask = mask_lock.sk_bitmap();
 
@@ skipping 15 matching lines @@
 
     SkLayerRasterizer::Builder builder;
     builder.addLayer(mask_paint);
 
     skia::RefPtr<SkLayerRasterizer> mask_rasterizer =
         skia::AdoptRef(builder.detachRasterizer());
 
     current_paint_.setRasterizer(mask_rasterizer.get());
     current_canvas_->drawRect(dest_visible_rect, current_paint_);
   } else {
-    // TODO(skaslev): Apply background filters and blend with content
+    // TODO(skaslev): Apply background filters
     current_canvas_->drawRect(dest_visible_rect, current_paint_);
   }
 }
 
 void SoftwareRenderer::DrawUnsupportedQuad(const DrawingFrame* frame,
                                            const DrawQuad* quad) {
 #ifdef NDEBUG
   current_paint_.setColor(SK_ColorWHITE);
 #else
   current_paint_.setColor(SK_ColorMAGENTA);
@@ skipping 41 matching lines @@
 }
 
 void SoftwareRenderer::DidChangeVisibility() {
   if (visible())
     EnsureBackbuffer();
   else
     DiscardBackbuffer();
 }
 
 }  // namespace cc