mix-blend-mode implementation for accelerated layers

cc/layers/layer.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/layers/layer.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/location.h"
@@ skipping 29 matching lines @@
       layer_tree_host_(NULL),
       scrollable_(false),
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
       anchor_point_(0.5f, 0.5f),
       background_color_(0),
       compositing_reasons_(kCompositingReasonUnknown),
       opacity_(1.f),
+      blend_mode_(SkXfermode::kSrcOver_Mode),
+      is_root_for_isolated_group_(false),
       anchor_point_z_(0.f),
       is_container_for_fixed_position_layers_(false),
       is_drawable_(false),
       hide_layer_and_subtree_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       double_sided_(true),
       preserves_3d_(false),
       use_parent_backface_visibility_(false),
       draw_checkerboard_for_missing_tiles_(false),
@@ skipping 58 matching lines @@
   if (host) {
     layer_animation_controller_->SetAnimationRegistrar(
         host->animation_registrar());
 
     if (host->settings().layer_transforms_should_scale_layer_contents)
       reset_raster_scale_to_unknown();
   }
 
   if (host && layer_animation_controller_->has_any_animation())
     host->SetNeedsCommit();
-  if (host && (!filters_.IsEmpty() || !background_filters_.IsEmpty()))
-    layer_tree_host_->set_needs_filter_context();
+  SetNeedsFilterContextIfNeeded();
 }
 
 void Layer::SetNeedsUpdate() {
   if (layer_tree_host_ && !ignore_set_needs_commit_)
     layer_tree_host_->SetNeedsUpdateLayers();
 }
 
 void Layer::SetNeedsCommit() {
   if (!layer_tree_host_)
     return;
@@ skipping 13 matching lines @@
   layer_tree_host_->SetNeedsFullTreeSync();
 }
 
 void Layer::SetNextCommitWaitsForActivation() {
   if (!layer_tree_host_)
     return;
 
   layer_tree_host_->SetNextCommitWaitsForActivation();
 }
 
+void Layer::SetNeedsFilterContextIfNeeded() {
+  if (!layer_tree_host_)
+    return;
+
+  if (!filters_.IsEmpty() || !background_filters_.IsEmpty() ||
+      !uses_default_blend_mode())
+    layer_tree_host_->set_needs_filter_context();
+}
+
 void Layer::SetNeedsPushProperties() {
   if (needs_push_properties_)
     return;
   if (!parent_should_know_need_push_properties() && parent_)
     parent_->AddDependentNeedsPushProperties();
   needs_push_properties_ = true;
 }
 
 void Layer::AddDependentNeedsPushProperties() {
   DCHECK_GE(num_dependents_need_push_properties_, 0);
@@ skipping 291 matching lines @@
   }
   SetNeedsFullTreeSync();
 }
 
 void Layer::SetFilters(const FilterOperations& filters) {
   DCHECK(IsPropertyChangeAllowed());
   if (filters_ == filters)
     return;
   filters_ = filters;
   SetNeedsCommit();
-  if (!filters.IsEmpty() && layer_tree_host_)
-    layer_tree_host_->set_needs_filter_context();
+  SetNeedsFilterContextIfNeeded();
 }
 
 bool Layer::FilterIsAnimating() const {
   return layer_animation_controller_->IsAnimatingProperty(Animation::Filter);
 }
 
 void Layer::SetBackgroundFilters(const FilterOperations& filters) {
   DCHECK(IsPropertyChangeAllowed());
   if (background_filters_ == filters)
     return;
   background_filters_ = filters;
   SetNeedsCommit();
-  if (!filters.IsEmpty() && layer_tree_host_)
-    layer_tree_host_->set_needs_filter_context();
+  SetNeedsFilterContextIfNeeded();
 }
 
 void Layer::SetOpacity(float opacity) {
   DCHECK(IsPropertyChangeAllowed());
   if (opacity_ == opacity)
     return;
   opacity_ = opacity;
   SetNeedsCommit();
 }
 
 bool Layer::OpacityIsAnimating() const {
   return layer_animation_controller_->IsAnimatingProperty(Animation::Opacity);
 }
 
 bool Layer::OpacityCanAnimateOnImplThread() const {
   return false;
 }
 
+void Layer::SetBlendMode(SkXfermode::Mode blend_mode) {
+  DCHECK(IsPropertyChangeAllowed());
+  if (blend_mode_ == blend_mode)
+    return;
+
+  // Allowing only blend modes that are defined in the CSS Compositing standard:
+  // http://dev.w3.org/fxtf/compositing-1/#blending
+  bool is_blend_mode = (blend_mode == SkXfermode::kSrcOver_Mode ||

[enne (OOO), 2013/11/04 22:38:16]

naming: is_blend_mode => supported_blend_mode or even just supported.  All the
SkXfermodes are technically blend modes.

[rosca, 2013/11/05 19:14:09]

We call the other modes "Compositing operators", but that's not very clear from
skia declaration of SkXfermodes.

+                        (blend_mode >= SkXfermode::kScreen_Mode &&
+                         blend_mode <= SkXfermode::kLastMode));

[enne (OOO), 2013/11/04 22:38:16]

This doesn't seem very futureproof.  Could you just make this a switch statement
(without default) and enumerate what's supported and what isn't?

[rosca, 2013/11/05 19:14:09]

Done.

+  DCHECK(is_blend_mode);
+  if (!is_blend_mode)
+    return;
+
+  blend_mode_ = blend_mode;
+  SetNeedsCommit();
+  SetNeedsFilterContextIfNeeded();
+}
+
+void Layer::SetIsRootForIsolatedGroup(bool root) {
+  DCHECK(IsPropertyChangeAllowed());
+  if (is_root_for_isolated_group_ == root)
+    return;
+  is_root_for_isolated_group_ = root;
+  SetNeedsCommit();
+}
+
 void Layer::SetContentsOpaque(bool opaque) {
   DCHECK(IsPropertyChangeAllowed());
   if (contents_opaque_ == opaque)
     return;
   contents_opaque_ = opaque;
   SetNeedsCommit();
 }
 
 void Layer::SetPosition(gfx::PointF position) {
   DCHECK(IsPropertyChangeAllowed());
@@ skipping 307 matching lines @@
   layer->SetBackgroundFilters(background_filters());
   layer->SetMasksToBounds(masks_to_bounds_);
   layer->SetShouldScrollOnMainThread(should_scroll_on_main_thread_);
   layer->SetHaveWheelEventHandlers(have_wheel_event_handlers_);
   layer->SetNonFastScrollableRegion(non_fast_scrollable_region_);
   layer->SetTouchEventHandlerRegion(touch_event_handler_region_);
   layer->SetContentsOpaque(contents_opaque_);
   if (!layer->OpacityIsAnimatingOnImplOnly() && !OpacityIsAnimating())
     layer->SetOpacity(opacity_);
   DCHECK(!(OpacityIsAnimating() && layer->OpacityIsAnimatingOnImplOnly()));
+  layer->SetBlendMode(blend_mode_);
+  layer->SetIsRootForIsolatedGroup(is_root_for_isolated_group_);
   layer->SetPosition(position_);
   layer->SetIsContainerForFixedPositionLayers(
       IsContainerForFixedPositionLayers());
   layer->SetFixedContainerSizeDelta(gfx::Vector2dF());
   layer->SetPositionConstraint(position_constraint_);
   layer->SetPreserves3d(preserves_3d());
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   layer->SetSublayerTransform(sublayer_transform_);
   if (!layer->TransformIsAnimatingOnImplOnly() && !TransformIsAnimating())
     layer->SetTransform(transform_);
@@ skipping 243 matching lines @@
     clip_parent_->RemoveClipChild(this);
 
   clip_parent_ = NULL;
 }
 
 void Layer::RunMicroBenchmark(MicroBenchmark* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 }  // namespace cc