mix-blend-mode implementation for accelerated layers - blink part

Source/core/rendering/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 162 matching lines @@
 private:
     Vector<OverlapMapContainer> m_overlapStack;
     HashSet<const RenderLayer*> m_layers;
     RenderGeometryMap m_geometryMap;
 };
 
 struct CompositingState {
     CompositingState(RenderLayer* compAncestor, bool testOverlap)
         : m_compositingAncestor(compAncestor)
         , m_subtreeIsCompositing(false)
+        , m_hasCompositedBlendingDescendents(false)
         , m_testingOverlap(testOverlap)
 #ifndef NDEBUG
         , m_depth(0)
 #endif
     {
     }
 
     CompositingState(const CompositingState& other)
         : m_compositingAncestor(other.m_compositingAncestor)
         , m_subtreeIsCompositing(other.m_subtreeIsCompositing)
+        , m_hasCompositedBlendingDescendents(other.m_hasCompositedBlendingDescendents)
         , m_testingOverlap(other.m_testingOverlap)
 #ifndef NDEBUG
         , m_depth(other.m_depth + 1)
 #endif
     {
     }
 
     RenderLayer* m_compositingAncestor;
     bool m_subtreeIsCompositing;
+    bool m_hasCompositedBlendingDescendents;
     bool m_testingOverlap;
 #ifndef NDEBUG
     int m_depth;
 #endif
 };
 
 
 static inline bool compositingLogEnabled()
 {
 #if !LOG_DISABLED
@@ skipping 559 matching lines @@
 //
 void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer* layer, OverlapMap* overlapMap, CompositingState& compositingState, bool& layersChanged, bool& descendantHas3DTransform)
 {
     layer->updateLayerListsIfNeeded();
 
     if (overlapMap)
         overlapMap->geometryMap().pushMappingsToAncestor(layer, ancestorLayer);
 
     // Clear the flag
     layer->setHasCompositingDescendant(false);
+    layer->setShouldIsolateCompositedBlendingDescendants(false);
 
     // Start by assuming this layer will not need to composite.
     CompositingReasons reasonsToComposite = CompositingReasonNone;
 
     // First accumulate the straightforward compositing reasons.
     CompositingReasons directReasons = directReasonsForCompositing(layer);
 
     // Video is special. It's the only RenderLayer type that can both have
     // RenderLayer children and whose children can't use its backing to render
     // into. These children (the controls) always need to be promoted into their
@@ skipping 114 matching lines @@
         if (inCompositingMode() && m_hasAcceleratedCompositing)
             willBeComposited = true;
     }
 
     // All layers (even ones that aren't being composited) need to get added to
     // the overlap map. Layers that do not composite will draw into their
     // compositing ancestor's backing, and so are still considered for overlap.
     if (overlapMap && childState.m_compositingAncestor && !childState.m_compositingAncestor->isRootLayer())
         addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds);
 
+    // According to http://dev.w3.org/fxtf/compositing-1/#csscompositingrules_CSS,
+    // an element that has blending applied, must blend with all the underlying
+    // content of the stacking context [CSS21] that element belongs to.
+    // We should isolate and accelerate the stacking contexts containing
+    // accelerated blending descendants
+    if (layer->isStackingContext())
+        layer->setShouldIsolateCompositedBlendingDescendants(childState.m_hasCompositedBlendingDescendents);
+    else
+        compositingState.m_hasCompositedBlendingDescendents = childState.m_hasCompositedBlendingDescendents;
+
     // Now check for reasons to become composited that depend on the state of descendant layers.
     CompositingReasons subtreeCompositingReasons = subtreeReasonsForCompositing(layer->renderer(), childState.m_subtreeIsCompositing, anyDescendantHas3DTransform);
     reasonsToComposite |= subtreeCompositingReasons;
     if (!willBeComposited && canBeComposited(layer) && requiresCompositing(subtreeCompositingReasons)) {
         childState.m_compositingAncestor = layer;
         if (overlapMap) {
             // FIXME: this context push is effectively a no-op but needs to exist for
             // now, because the code is designed to push overlap information to the
             // second-from-top context of the stack.
             overlapMap->beginNewOverlapTestingContext();
             addToOverlapMapRecursive(*overlapMap, layer);
         }
         willBeComposited = true;
     }
 
     // If the original layer is composited, the reflection needs to be, too.
     if (layer->reflectionLayer()) {
         // FIXME: Shouldn't we call computeCompositingRequirements to handle a reflection overlapping with another renderer?
         CompositingReasons reflectionCompositingReason = willBeComposited ? CompositingReasonReflectionOfCompositedParent : CompositingReasonNone;
         layer->reflectionLayer()->setCompositingReasons(layer->reflectionLayer()->compositingReasons() | reflectionCompositingReason);
     }
 
     // Subsequent layers in the parent's stacking context may also need to composite.
     if (childState.m_subtreeIsCompositing)
         compositingState.m_subtreeIsCompositing = true;
+    if (willBeComposited && layer->hasBlendMode())
+        compositingState.m_hasCompositedBlendingDescendents = true;
 
     // Set the flag to say that this SC has compositing children.
     layer->setHasCompositingDescendant(childState.m_subtreeIsCompositing);
 
 
     // Turn overlap testing off for later layers if it's already off, or if we have an animating transform.
     // Note that if the layer clips its descendants, there's no reason to propagate the child animation to the parent layers. That's because
     // we know for sure the animation is contained inside the clipping rectangle, which is already added to the overlap map.
     bool isCompositedClippingLayer = canBeComposited(layer) && (reasonsToComposite & CompositingReasonClipsCompositingDescendants);
     if ((!childState.m_testingOverlap && !isCompositedClippingLayer) || isRunningAcceleratedTransformAnimation(layer->renderer()))
@@ skipping 617 matching lines @@
         return true;
 
     CompositingReasons indirectReasonsThatNeedBacking = CompositingReasonOverlap
         | CompositingReasonAssumedOverlap
         | CompositingReasonNegativeZIndexChildren
         | CompositingReasonTransformWithCompositedDescendants
         | CompositingReasonOpacityWithCompositedDescendants
         | CompositingReasonMaskWithCompositedDescendants
         | CompositingReasonFilterWithCompositedDescendants
         | CompositingReasonBlendingWithCompositedDescendants
+        | CompositingReasonIsolateCompositedDescendants
         | CompositingReasonPreserve3D; // preserve-3d has to create backing store to ensure that 3d-transformed elements intersect.
     return layer->compositingReasons() & indirectReasonsThatNeedBacking;
 }
 
 CompositingReasons RenderLayerCompositor::directReasonsForCompositing(const RenderLayer* layer) const
 {
     RenderObject* renderer = layer->renderer();
     CompositingReasons directReasons = CompositingReasonNone;
 
     if (requiresCompositingForTransform(renderer))
@@ skipping 304 matching lines @@
     CompositingReasons subtreeReasons = CompositingReasonNone;
 
     // FIXME: this seems to be a potentially different layer than the layer for which this was called. May not be an error, but is very confusing.
     RenderLayer* layer = toRenderBoxModelObject(renderer)->layer();
 
     // When a layer has composited descendants, some effects, like 2d transforms, filters, masks etc must be implemented
     // via compositing so that they also apply to those composited descdendants.
     if (hasCompositedDescendants) {
         if (layer->transform())
             subtreeReasons |= CompositingReasonTransformWithCompositedDescendants;
+        if (layer->shouldIsolateCompositedBlendingDescendants())
+            subtreeReasons |= CompositingReasonIsolateCompositedDescendants;
 
         // If the implementation of createsGroup changes, we need to be aware of that in this part of code.
         ASSERT((renderer->isTransparent() || renderer->hasMask() || renderer->hasFilter() || renderer->hasBlendMode()) == renderer->createsGroup());
         if (renderer->isTransparent())
             subtreeReasons |= CompositingReasonOpacityWithCompositedDescendants;
         if (renderer->hasMask())
             subtreeReasons |= CompositingReasonMaskWithCompositedDescendants;
         if (renderer->hasFilter())
             subtreeReasons |= CompositingReasonFilterWithCompositedDescendants;
         if (renderer->hasBlendMode())
@@ skipping 793 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "Frame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore