Store compositor element id in paint properties for animated objects.

third_party/WebKit/Source/core/paint/PaintPropertyTreeBuilder.cpp

 // Copyright 2015 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 "core/paint/PaintPropertyTreeBuilder.h"
 
+#include "core/dom/DOMNodeIds.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/compositing/CompositingReasonFinder.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/paint/FindPropertiesNeedingUpdate.h"
 #include "core/paint/ObjectPaintProperties.h"
@@ skipping 351 matching lines @@
 
         // TODO(trchen): transform-style should only be respected if a
         // PaintLayer
         // is created.
         // If a node with transform-style: preserve-3d does not exist in an
         // existing rendering context, it establishes a new one.
         unsigned renderingContextID = context.current.renderingContextID;
         if (style.preserves3D() && !renderingContextID)
           renderingContextID = PtrHash<const LayoutObject>::hash(&object);
 
+        CompositorElementId compositorElementId;
+        if (style.hasCurrentTransformAnimation()) {

[wkorman, 2016/12/29 20:22:54]

To call out, I made a judgement call here (and same for effect node) wherein:
- we only generate an element id when we have an animation
- if the animation stops, we remove the element id from the node

Both are debatable. I figure it's easy to change later if we decide/discover
we'd like to do so. I'm not currently aware of a reason why as written is
unsuitable. Iteration expected down the road, as it were.

[Xianzhu, 2016/12/29 20:40:38]

Is there any extra cost for a paint property node having compositorElementId? If
not, can we just always set compositorElementId and never change it regardless
of animation?

[wkorman, 2016/12/29 20:59:15]

Yes, we use DOMNodeIds::idForNode() which uses a WeakIdentifierMap, which in the
end
has a static int that it increments and also a map to ensure we produce the same
identifier for that node in the future. So the cost is the perf overhead of
doing
this plus memory in the map.

I wasn't involved, but chrishtr@ said there was debate in the past about whether
the overhead is material. For now I figured it was most expedient to preserve
current behavior and we could explore performance and potential code
simplification
later, but am open to changing approach, measuring now, etc.

This is what ajuma@ is referring to in http://crbug.com/674258#c1 (4). vollick@
change that added the element id to layers explicitly did so only for those
layers that had an animation due to concern re: the overhead.

+          updateCompositorElementId(object, compositorElementId);
+        }
+
         auto& properties =
             object.getMutableForPainting().ensurePaintProperties();
         context.forceSubtreeUpdate |= properties.updateTransform(
             context.current.transform, matrix, transformOrigin(box),
             context.current.shouldFlattenInheritedTransform, renderingContextID,
-            compositingReasons);
+            compositingReasons, compositorElementId);
         hasTransform = true;
       }
     }
     if (!hasTransform) {
       if (auto* properties = object.getMutableForPainting().paintProperties())
         context.forceSubtreeUpdate |= properties->clearTransform();
     }
   }
 
   const auto* properties = object.paintProperties();
@@ skipping 83 matching lines @@
     if (!filter.isEmpty()) {
       effectNodeNeeded = true;
       outputClip = context.current.clip;
 
       // TODO(trchen): A filter may contain spatial operations such that an
       // output pixel may depend on an input pixel outside of the output clip.
       // We should generate a special clip node to represent this expansion.
     }
 
     CompositingReasons compositingReasons =
-        CompositingReasonFinder::requiresCompositingForEffectAnimation(
-            object.styleRef());
+        CompositingReasonFinder::requiresCompositingForEffectAnimation(style);
     if (compositingReasons != CompositingReasonNone)
       effectNodeNeeded = true;
 
+    CompositorElementId compositorElementId;
+    if (style.hasCurrentOpacityAnimation() ||
+        style.hasCurrentFilterAnimation() ||
+        style.hasCurrentBackdropFilterAnimation()) {
+      updateCompositorElementId(object, compositorElementId);
+    }
+
     if (effectNodeNeeded) {
       auto& properties = object.getMutableForPainting().ensurePaintProperties();
       context.forceSubtreeUpdate |= properties.updateEffect(
           context.currentEffect, context.current.transform, outputClip,
-          std::move(filter), opacity, blendMode, compositingReasons);
+          std::move(filter), opacity, blendMode, compositingReasons,
+          compositorElementId);
     } else {
       if (auto* properties = object.getMutableForPainting().paintProperties())
         context.forceSubtreeUpdate |= properties->clearEffect();
     }
   }
 
   const auto* properties = object.paintProperties();
   if (properties && properties->effect()) {
     context.currentEffect = properties->effect();
     if (!properties->effect()->filter().isEmpty()) {
@@ skipping 321 matching lines @@
       return;
     }
   }
 
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     if (auto* properties = object.getMutableForPainting().paintProperties())
       context.forceSubtreeUpdate |= properties->clearCssClipFixedPosition();
   }
 }
 
+void PaintPropertyTreeBuilder::updateCompositorElementId(
+    const LayoutObject& object,
+    CompositorElementId& compositorElementId) {
+  compositorElementId = createCompositorElementId(
+      DOMNodeIds::idForNode(object.node()), CompositorSubElementId::Primary);
+}
+
 // Override ContainingBlockContext based on the properties of a containing block
 // that was previously walked in a subtree other than the current subtree being
 // walked. Used for out-of-flow positioned descendants of multi-column spanner
 // when the containing block is not in the normal tree walk order.
 // For example:
 // <div id="columns" style="columns: 2">
 //   <div id="relative" style="position: relative">
 //     <div id="spanner" style="column-span: all">
 //       <div id="absolute" style="position: absolute"></div>
 //     </div>
@@ skipping 138 matching lines @@
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 
   context.forceSubtreeUpdate |= object.subtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink