mix-blend-mode implementation for accelerated layers

cc/layers/layer.h

 // 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.
 
 #ifndef CC_LAYERS_LAYER_H_
 #define CC_LAYERS_LAYER_H_
 
 #include <set>
 #include <string>
 
@@ skipping 108 matching lines @@
   const Layer* mask_layer() const { return mask_layer_.get(); }
 
   virtual void SetNeedsDisplayRect(const gfx::RectF& dirty_rect);
   void SetNeedsDisplay() { SetNeedsDisplayRect(gfx::RectF(bounds())); }
 
   void SetOpacity(float opacity);
   float opacity() const { return opacity_; }
   bool OpacityIsAnimating() const;
   virtual bool OpacityCanAnimateOnImplThread() const;
 
+  void SetBlendMode(SkXfermode::Mode blend_mode);

[enne (OOO), 2013/11/01 18:49:02]

Can you help my understanding of the blend mode spec here? It is the case here
that there are a number of SkXfermode enums that aren't web-accessible via the
mix-blend-mode attribute, right?

The compositor invariant that I'd like to maintain is that creating a render
surface at any layer should always create the same resulting pixels.

In particular, there are some problematic SkXfermodes that I am concerned about.
 To list just two: kSrc_Mode which I think corresponds to Porter Duff Copy and
kClear_Mode which corresponds to Porter Duff Clear.

These two blend modes listed above (among others) are problematic in that even
for pixels where source alpha is 0, applying that blend mode will clobber the
destination alpha.

Since render surfaces are just arbitrarily sized to be the union of all the
layers that draw into them, any alpha=0 pixels between layers in that
arbitrarily-sized surface could affect destination alpha with certain blend
modes.  And, therefore the existence and presence of render surfaces will change
the final rendering because that will change that shape.

One solution would be to mask to bounds for any of these types.  Another
short-term solution would be to only support the web-accessible blend modes on
cc::Layer and ignore/DCHECK others.  What do you think?

(This came up yesterday in the context of http://crbug.com/313494 where there's
some need to make layers be able to do something like blend with kSrc_Mode and
so it intersects with this work.)

[rosca, 2013/11/04 17:14:35]

It sounds good, thanks. I added checks for this.

+  SkXfermode::Mode blend_mode() const { return blend_mode_; }
+
+  bool uses_default_blend_mode() const {
+    return blend_mode_ == SkXfermode::kSrcOver_Mode;
+  }
+
+  void SetIsRootForIsolatedGroup(bool root);
+  bool is_root_for_isolated_group() const {
+    return is_root_for_isolated_group_;
+  }
+
   void SetFilters(const FilterOperations& filters);
   const FilterOperations& filters() const { return filters_; }
   bool FilterIsAnimating() const;
 
   // Background filters are filters applied to what is behind this layer, when
   // they are viewed through non-opaque regions in this layer. They are used
   // through the WebLayer interface, and are not exposed to HTML.
   void SetBackgroundFilters(const FilterOperations& filters);
   const FilterOperations& background_filters() const {
     return background_filters_;
@@ skipping 407 matching lines @@
   bool have_wheel_event_handlers_;
   bool user_scrollable_horizontal_;
   bool user_scrollable_vertical_;
   Region non_fast_scrollable_region_;
   Region touch_event_handler_region_;
   gfx::PointF position_;
   gfx::PointF anchor_point_;
   SkColor background_color_;
   CompositingReasons compositing_reasons_;
   float opacity_;
+  SkXfermode::Mode blend_mode_;
+  bool is_root_for_isolated_group_;
   FilterOperations filters_;
   FilterOperations background_filters_;
   float anchor_point_z_;
   bool is_container_for_fixed_position_layers_;
   LayerPositionConstraint position_constraint_;
   bool is_drawable_;
   bool hide_layer_and_subtree_;
   bool masks_to_bounds_;
   bool contents_opaque_;
   bool double_sided_;
@@ skipping 25 matching lines @@
   DrawProperties<Layer> draw_properties_;
 
   PaintProperties paint_properties_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_H_