Update transform paint property's transform-offset on element size changes

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/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 250 matching lines @@
     if (RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
         object.isLayoutView()) {
       context.absolutePosition.transform = properties->paintOffsetTranslation();
       context.fixedPosition.transform = properties->paintOffsetTranslation();
       context.absolutePosition.paintOffset = LayoutPoint();
       context.fixedPosition.paintOffset = LayoutPoint();
     }
   }
 }
 
-static FloatPoint3D transformOrigin(const LayoutBox& box) {
-  const ComputedStyle& style = box.styleRef();
-  FloatSize borderBoxSize(box.size());
-  return FloatPoint3D(
-      floatValueForLength(style.transformOriginX(), borderBoxSize.width()),
-      floatValueForLength(style.transformOriginY(), borderBoxSize.height()),
-      style.transformOriginZ());
-}
-
 // SVG does not use the general transform update of |updateTransform|, instead
 // creating a transform node for SVG-specific transforms without 3D.
 void PaintPropertyTreeBuilder::updateTransformForNonRootSVG(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   DCHECK(object.isSVG() && !object.isSVGRoot());
   // SVG does not use paint offset internally, except for SVGForeignObject which
   // has different SVG and HTML coordinate spaces.
   DCHECK(object.isSVGForeignObject() ||
          context.current.paintOffset == LayoutPoint());
@@ skipping 33 matching lines @@
           object.styleRef()))
     compositingReasons |= CompositingReasonActiveAnimation;
 
   if (object.styleRef().hasWillChangeCompositingHint() &&
       !object.styleRef().subtreeWillChangeContents())
     compositingReasons |= CompositingReasonWillChangeCompositingHint;
 
   return compositingReasons;
 }
 
+static FloatPoint3D transformOrigin(const LayoutBox& box) {
+  const ComputedStyle& style = box.styleRef();
+  // 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());
+}
+
 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();
 
     CompositingReasons compositingReasons =
         compositingReasonsForTransform(object);
 
     // A transform node is allocated for transforms, preserves-3d and any
     // direct compositing reason. The latter is required because this is the
     // only way to represent compositing both an element and its stacking
     // descendants.
     if (object.isBox() && (style.hasTransform() || style.preserves3D() ||
                            compositingReasons != CompositingReasonNone)) {
+      auto& box = toLayoutBox(object);
       TransformationMatrix matrix;
       style.applyTransform(
-          matrix, toLayoutBox(object).size(),
-          ComputedStyle::ExcludeTransformOrigin,
+          matrix, box.size(), ComputedStyle::ExcludeTransformOrigin,
           ComputedStyle::IncludeMotionPath,
           ComputedStyle::IncludeIndependentTransformProperties);
 
       // 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);
 
       auto& properties = object.getMutableForPainting().ensurePaintProperties();
       context.forceSubtreeUpdate |= properties.updateTransform(
-          context.current.transform, matrix,
-          transformOrigin(toLayoutBox(object)),
+          context.current.transform, matrix, transformOrigin(box),
           context.current.shouldFlattenInheritedTransform, renderingContextID,
           compositingReasons);
     } else {
       if (auto* properties = object.getMutableForPainting().paintProperties())
         context.forceSubtreeUpdate |= properties->clearTransform();
     }
   }
 
   const auto* properties = object.paintProperties();
   if (properties && properties->transform()) {
@@ skipping 581 matching lines @@
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 
   context.forceSubtreeUpdate |= object.subtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink