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

Source/core/rendering/RenderLayerCompositor.cpp

Index: Source/core/rendering/RenderLayerCompositor.cpp
diff --git a/Source/core/rendering/RenderLayerCompositor.cpp b/Source/core/rendering/RenderLayerCompositor.cpp
index d3d203369b95fc7c92df4d1c9d723c1a2a85be29..b4c8ad3d1cb7da545a04003d3b7199c8d234e651 100644
--- a/Source/core/rendering/RenderLayerCompositor.cpp
+++ b/Source/core/rendering/RenderLayerCompositor.cpp
@@ -180,6 +180,7 @@ struct CompositingState {
     CompositingState(RenderLayer* compAncestor, bool testOverlap)
         : m_compositingAncestor(compAncestor)
         , m_subtreeIsCompositing(false)
+        , m_hasCompositedBlendingDescendents(false)

[shawnsingh, 2013/09/13 10:22:59]

Let's spell it "Descendants" instead... that way the spelling is consistent with
what already exists in the code.

[rosca, 2013/09/19 14:26:54]

Done.

         , m_testingOverlap(testOverlap)
 #ifndef NDEBUG
         , m_depth(0)
@@ -190,6 +191,7 @@ struct CompositingState {
     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)
@@ -199,6 +201,7 @@ struct CompositingState {
 
     RenderLayer* m_compositingAncestor;
     bool m_subtreeIsCompositing;
+    bool m_hasCompositedBlendingDescendents;
     bool m_testingOverlap;
 #ifndef NDEBUG
     int m_depth;
@@ -784,6 +787,7 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
 
     // Clear the flag
     layer->setHasCompositingDescendant(false);
+    layer->setShouldIsolateCompositedBlendingDescendants(false);
 
     // Start by assuming this layer will not need to composite.
     CompositingReasons reasonsToComposite = CompositingReasonNone;
@@ -943,6 +947,16 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
     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

[shawnsingh, 2013/09/13 10:22:59]

nit - remove the comma after "applied"

[rosca, 2013/09/19 14:26:54]

Done.

+    // 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())

[shawnsingh, 2013/09/13 10:22:59]

OK - please bear with me =)

(1) This part of the patch seems to depend on exactly how you intend to
implement blend modes on the back-end in cc/  Can you please give some details
about that?

(2) I would feel much more comfortable if we redundantly and explicitly set all
values in both cases.  The efficiency cost is negligible, but it removes the
need to rely on assumptions about recursive state that come from distant places.
 It's becoming increasingly important to avoid unnecessary assumptions in this
part of the code.

if (layer->isStackingContext()) {
   
layer->setShouldIsolateCompositedBlendingDescendants(childState.m_hasCompositedBlendingDescdendents)
    compositingState.m_hasCompositedBlendingDescendents = false;
} else {
    layer->setShouldIsolateCompositedBlendingDescendants(false);
    compositingState.m_hasCompositedBlendingDescendents =
childState.m_hasCompositedBlendingDescdendents;
}


(3) Also, another issue, what happens when there is a composited layer
in-between the stacking context and the composited blending descendant?  Or is
that case guaranteed not to happen for some reason?

[rosca, 2013/09/19 14:26:54]

This part of the code should make sure that a stacking contexts, containing at
least one accelerated blending descendant (not entering other descending
stacking contexts), will be accelerated too. This will help the compositor to
"isolate" the layer being a stacking context so that the blending descendant
will not be able to access the color information outside this stacking context
for the backdrop.

rendererLayerCompositor just accelerates root layers for isolated groups and
tells the compositor that they are root layers for isolated groups
(updateIsRootForIsolatedGroup). 

The compositor will create create a separate rendering surface for each isolated
group.
Done. I made some changes here and things should be more clear now.
It is possible to have accelerated layers behind the blending layer in the same
stacking context. The backdrop is the composition of all the accelerated layers
which go behind the blending layer in the current stacking context.
In computeCompositingRequirements - if the current layer has blending
descendants, is not a stacking context and it will be accelerated, the
m_hasCompositedBlendingDescdendents property is passed to its parent, up to the
first layer being a stacking context.

+        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;
@@ -968,6 +982,8 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
     // 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);
@@ -1605,6 +1621,7 @@ bool RenderLayerCompositor::requiresOwnBackingStore(const RenderLayer* layer, co
         | CompositingReasonMaskWithCompositedDescendants
         | CompositingReasonFilterWithCompositedDescendants
         | CompositingReasonBlendingWithCompositedDescendants
+        | CompositingReasonIsolateCompositedDescendants
         | CompositingReasonPreserve3D; // preserve-3d has to create backing store to ensure that 3d-transformed elements intersect.
     return layer->compositingReasons() & indirectReasonsThatNeedBacking;
 }
@@ -1741,6 +1758,9 @@ const char* RenderLayerCompositor::logReasonsForCompositing(const RenderLayer* l
     if (reasons & CompositingReasonRoot)
         return "root";
 
+    if (reasons & CompositingReasonIsolateCompositedDescendants)
+        return "isolate composited descendants";
+
     return "";
 }
 #endif
@@ -1929,6 +1949,8 @@ CompositingReasons RenderLayerCompositor::subtreeReasonsForCompositing(RenderObj
     if (hasCompositedDescendants) {
         if (layer->transform())
             subtreeReasons |= CompositingReasonTransformWithCompositedDescendants;
+        if (layer->shouldIsolateCompositedBlendingDescendants())

[shawnsingh, 2013/09/13 10:22:59]

So it seems like this boolean value,
shouldIsolateCompositedBlendingDescendants() is really only used here.   It is
used in one ASSERT statement in RenderLayerBacking, but perhaps there's
something else that could be ASSERTed instead?

If that's true, then I think we should remove that accessor,
shouldIsolateCompositedBlendingDescendants(), and put the conditions of logic
directly in here.  Maybe instead of adding another arg to
subtreeReasonsForCompositing(), we could just pass compositingState itself to
this function.

Doing this would also simplify the if-statement that is being added to
computeCompositingRequirements().

[rosca, 2013/09/19 14:26:54]

This property is used in RenderLayerBacking::updateRootForIsolatedGroup, not
only in the ASSERT. shouldIsolateBlendingDescendants==true means that the
accelerated layer is going to isolate its layer subtree with a new rendering
surface and the software layer is going to create a new skia bitmap to render
the subtree separately (https://codereview.chromium.org/23503046/). I removed
the "Composited" part from and it became shouldIsolateBlendingDescendants.
I simplified the if-statement from computeCompositingRequirements

+            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());