mix-blend-mode implementation for accelerated layers

cc/layers/layer_impl.cc

 // Copyright 2011 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_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/strings/stringprintf.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/scrollbar_animation_controller.h"
@@ skipping 32 matching lines @@
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
       background_color_(0),
       stacking_order_changed_(false),
       double_sided_(true),
       layer_property_changed_(false),
       layer_surface_property_changed_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       opacity_(1.0),
+      blend_mode_(SkXfermode::kSrcOver_Mode),
+      is_root_for_isolated_group_(false),
       preserves_3d_(false),
       use_parent_backface_visibility_(false),
       draw_checkerboard_for_missing_tiles_(false),
       draws_content_(false),
       hide_layer_and_subtree_(false),
       force_render_surface_(false),
       is_container_for_fixed_position_layers_(false),
       draw_depth_(0.f),
       compositing_reasons_(kCompositingReasonUnknown),
       current_draw_mode_(DRAW_MODE_NONE),
@@ skipping 173 matching lines @@
   draw_properties_.render_surface.reset();
 }
 
 scoped_ptr<SharedQuadState> LayerImpl::CreateSharedQuadState() const {
   scoped_ptr<SharedQuadState> state = SharedQuadState::Create();
   state->SetAll(draw_properties_.target_space_transform,
                 draw_properties_.content_bounds,
                 draw_properties_.visible_content_rect,
                 draw_properties_.clip_rect,
                 draw_properties_.is_clipped,
-                draw_properties_.opacity);
+                draw_properties_.opacity,
+                blend_mode_);
   return state.Pass();
 }
 
 bool LayerImpl::WillDraw(DrawMode draw_mode,
                          ResourceProvider* resource_provider) {
   // WillDraw/DidDraw must be matched.
   DCHECK_NE(DRAW_MODE_NONE, draw_mode);
   DCHECK_EQ(DRAW_MODE_NONE, current_draw_mode_);
   current_draw_mode_ = draw_mode;
   return true;
@@ skipping 244 matching lines @@
   layer->SetHideLayerAndSubtree(hide_layer_and_subtree_);
   layer->SetFilters(filters());
   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_);
   layer->SetOpacity(opacity_);
+  layer->SetBlendMode(blend_mode_);
+  layer->SetIsRootForIsolatedGroup(is_root_for_isolated_group_);
   layer->SetPosition(position_);
   layer->SetIsContainerForFixedPositionLayers(
       is_container_for_fixed_position_layers_);
   layer->SetFixedContainerSizeDelta(fixed_container_size_delta_);
   layer->SetPositionConstraint(position_constraint_);
   layer->SetPreserves3d(preserves_3d());
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   layer->SetSublayerTransform(sublayer_transform_);
   layer->SetTransform(transform_);
 
@@ skipping 336 matching lines @@
 bool LayerImpl::OpacityIsAnimating() const {
   return layer_animation_controller_->IsAnimatingProperty(Animation::Opacity);
 }
 
 bool LayerImpl::OpacityIsAnimatingOnImplOnly() const {
   Animation* opacity_animation =
       layer_animation_controller_->GetAnimation(Animation::Opacity);
   return opacity_animation && opacity_animation->is_impl_only();
 }
 
+void LayerImpl::SetBlendMode(SkXfermode::Mode blendMode) {
+  if (blend_mode_ == blendMode)
+    return;
+
+  blend_mode_ = blendMode;
+  NoteLayerSurfacePropertyChanged();
+}
+
+void LayerImpl::SetIsRootForIsolatedGroup(bool root) {
+  if (is_root_for_isolated_group_ == root)
+    return;
+
+  is_root_for_isolated_group_ = root;
+  NoteLayerSurfacePropertyChanged();

[enne (OOO), 2013/10/11 18:14:35]

Should this really cause damage? It seems to me that the damage should all be
from the child's surface that is blending and not on the root for the isolated
group, and this can be removed.

[rosca, 2013/10/16 14:54:47]

Done.

+}
+
 void LayerImpl::SetPosition(gfx::PointF position) {
   if (position_ == position)
     return;
 
   position_ = position;
   NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::SetPreserves3d(bool preserves3_d) {
   if (preserves_3d_ == preserves3_d)
@@ skipping 376 matching lines @@
 
   if (reasons & kCompositingReasonLayerForMask)
     reason_list->AppendString("Is a mask layer");
 
   if (reasons & kCompositingReasonOverflowScrollingParent)
     reason_list->AppendString("Scroll parent is not an ancestor");
 
   if (reasons & kCompositingReasonOutOfFlowClipping)
     reason_list->AppendString("Has clipping ancestor");
 
+  if (reasons & kCompositingReasonIsolateCompositedDescendants)
+    reason_list->AppendString("Should isolate composited dscendants");
+
   return reason_list.PassAs<base::Value>();
 }
 
 void LayerImpl::AsValueInto(base::DictionaryValue* state) const {
   TracedValue::MakeDictIntoImplicitSnapshot(state, LayerTypeAsString(), this);
   state->SetInteger("layer_id", id());
   state->SetString("layer_name", debug_name());
   state->Set("bounds", MathUtil::AsValue(bounds()).release());
   state->SetInteger("draws_content", DrawsContent());
   state->SetInteger("gpu_memory_usage", GPUMemoryUsageInBytes());
@@ skipping 40 matching lines @@
 
 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
 
 scoped_ptr<base::Value> LayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   AsValueInto(state.get());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc