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 312 matching lines @@
   // Transform origin has no effect without a transform or motion path.
   if (!style.hasTransform())
     return FloatPoint3D();
   FloatSize borderBoxSize(box.size());
   return FloatPoint3D(
       floatValueForLength(style.transformOriginX(), borderBoxSize.width()),
       floatValueForLength(style.transformOriginY(), borderBoxSize.height()),
       style.transformOriginZ());
 }
 
+namespace {
+
+CompositorElementId createDomNodeBasedCompositorElementId(
+    const LayoutObject& object) {
+  return createCompositorElementId(DOMNodeIds::idForNode(object.node()),
+                                   CompositorSubElementId::Primary);
+}
+
+}  // namespace
+
 void PaintPropertyTreeBuilder::updateTransform(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.isSVG() && !object.isSVGRoot()) {
     updateTransformForNonRootSVG(object, context);
     return;
   }
 
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     const ComputedStyle& style = object.styleRef();
@@ skipping 19 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 =
+            style.hasCurrentTransformAnimation()
+                ? createDomNodeBasedCompositorElementId(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 =
+        (style.hasCurrentOpacityAnimation() ||
+         style.hasCurrentFilterAnimation() ||
+         style.hasCurrentBackdropFilterAnimation())
+            ? createDomNodeBasedCompositorElementId(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 479 matching lines @@
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 
   context.forceSubtreeUpdate |= object.subtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink