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)

[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)
 #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 565 matching lines @@
 //
 void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer* layer, OverlapMap* overlapMap, CompositingState& compositingState, bool& layersChanged, bool& descendantHas3DTransform, Vector<RenderLayer*>& unclippedDescendants)
 {
     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 139 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

[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;
     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 116 matching lines @@
 
     if (reasons & CompositingReasonPerspective)
         return "perspective";
 
     if (reasons & CompositingReasonPreserve3D)
         return "preserve-3d";
 
     if (reasons & CompositingReasonRoot)
         return "root";
 
+    if (reasons & CompositingReasonIsolateCompositedDescendants)
+        return "isolate composited descendants";
+
     return "";
 }
 #endif
 
 // Return true if the given layer has some ancestor in the RenderLayer hierarchy that clips,
 // up to the enclosing compositing ancestor. This is required because compositing layers are parented
 // according to the z-order hierarchy, yet clipping goes down the renderer hierarchy.
 // Thus, a RenderLayer can be clipped by a RenderLayer that is an ancestor in the renderer hierarchy,
 // but a sibling in the z-order hierarchy.
 bool RenderLayerCompositor::clippedByAncestor(RenderLayer* layer) const
@@ skipping 168 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())

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