Adding support for blending in cc::SoftwareRenderer

cc/output/software_renderer.cc

Index: cc/output/software_renderer.cc
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 88b9c646c924956c054074ad6d7c804442a2fdd5..48ce440b2d61d598325cbfc7102e363bb1470405 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -510,6 +510,9 @@ void SoftwareRenderer::DrawRenderPassQuad(const DrawingFrame* frame,
   }
   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);
@@ -545,7 +548,7 @@ void SoftwareRenderer::DrawRenderPassQuad(const DrawingFrame* frame,
     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_);
   }
 }