Correctly position abspos content inside relpos inlines [spv2]

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/Settings.h"
+#include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutPart.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
 #include "platform/transforms/TransformationMatrix.h"
 
 namespace blink {
 
 // The context for layout tree walk.
 // The walk will be done in the primary tree order (= DOM order), thus the context will also be
 // responsible for bookkeeping tree state in other order, for example, the most recent position
 // container seen.
 struct PaintPropertyTreeBuilderContext {
     PaintPropertyTreeBuilderContext()
         : currentTransform(nullptr)
         , currentClip(nullptr)
         , transformForAbsolutePosition(nullptr)
+        , containerForAbsolutePosition(nullptr)
         , clipForAbsolutePosition(nullptr)
         , transformForFixedPosition(nullptr)
         , clipForFixedPosition(nullptr)
         , currentEffect(nullptr) { }
 
     // The combination of a transform and paint offset describes a linear space.
     // When a layout object recur to its children, the main context is expected to refer
     // the object's border box, then the callee will derive its own border box by translating
     // the space with its own layout location.
     TransformPaintPropertyNode* currentTransform;
     LayoutPoint paintOffset;
     // The clip node describes the accumulated raster clip for the current subtree.
     // Note that the computed raster region in canvas space for a clip node is independent from
     // the transform and paint offset above. Also the actual raster region may be affected
     // by layerization and occlusion tracking.
     ClipPaintPropertyNode* currentClip;
 
     // Separate context for out-of-flow positioned and fixed positioned elements are needed
     // because they don't use DOM parent as their containing block.
     // These additional contexts normally pass through untouched, and are only copied from
     // the main context when the current element serves as the containing block of corresponding
     // positioned descendants.
     // Overflow clips are also inherited by containing block tree instead of DOM tree, thus they
     // are included in the additional context too.
     TransformPaintPropertyNode* transformForAbsolutePosition;
     LayoutPoint paintOffsetForAbsolutePosition;
+    LayoutObject* containerForAbsolutePosition;
     ClipPaintPropertyNode* clipForAbsolutePosition;
 
     TransformPaintPropertyNode* transformForFixedPosition;
     LayoutPoint paintOffsetForFixedPosition;
     ClipPaintPropertyNode* clipForFixedPosition;
 
     // The effect hierarchy is applied by the stacking context tree. It is guaranteed that every
     // DOM descendant is also a stacking context descendant. Therefore, we don't need extra
     // bookkeeping for effect nodes and can generate the effect tree from a DOM-order traversal.
     EffectPaintPropertyNode* currentEffect;
@@ skipping 42 matching lines @@
 
     FloatRoundedRect contentClip(IntRect(IntPoint(), frameView.visibleContentSize()));
     RefPtr<ClipPaintPropertyNode> newClipNodeForContentClip = ClipPaintPropertyNode::create(newTransformNodeForPreTranslation.get(), contentClip, localContext.currentClip);
     localContext.currentClip = localContext.clipForAbsolutePosition = localContext.clipForFixedPosition = newClipNodeForContentClip.get();
 
     DoubleSize scrollOffset = frameView.scrollOffsetDouble();
     TransformationMatrix frameScroll;
     frameScroll.translate(-scrollOffset.width(), -scrollOffset.height());
     RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = TransformPaintPropertyNode::create(frameScroll, FloatPoint3D(), newTransformNodeForPreTranslation);
     localContext.currentTransform = localContext.transformForAbsolutePosition = newTransformNodeForScrollTranslation.get();
-    localContext.paintOffset = localContext.paintOffsetForAbsolutePosition = LayoutPoint();
+    localContext.paintOffset = LayoutPoint();
+    localContext.paintOffsetForAbsolutePosition = LayoutPoint();
+    localContext.containerForAbsolutePosition = nullptr;
 
     frameView.setPreTranslation(newTransformNodeForPreTranslation.release());
     frameView.setScrollTranslation(newTransformNodeForScrollTranslation.release());
     frameView.setContentClip(newClipNodeForContentClip.release());
 
     if (LayoutView* layoutView = frameView.layoutView())
         walk(*layoutView, localContext);
 }
 
 void PaintPropertyTreeBuilder::updatePaintOffsetTranslation(LayoutObject& object, PaintPropertyTreeBuilderContext& context)
@@ skipping 200 matching lines @@
     context.currentTransform = scrollTranslation.get();
     object.ensureObjectPaintProperties().setScrollTranslation(scrollTranslation.release());
 }
 
 void PaintPropertyTreeBuilder::updateOutOfFlowContext(LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (object.canContainAbsolutePositionObjects()) {
         context.transformForAbsolutePosition = context.currentTransform;
         context.paintOffsetForAbsolutePosition = context.paintOffset;
         context.clipForAbsolutePosition = context.currentClip;
+        context.containerForAbsolutePosition = &object;
     }
 
     // TODO(pdr): Remove the !object.isLayoutView() condition when removing FrameView
     // paint properties for rootLayerScrolls.
     if (!object.isLayoutView() && object.canContainFixedPositionObjects()) {
         context.transformForFixedPosition = context.currentTransform;
         context.paintOffsetForFixedPosition = context.paintOffset;
         context.clipForFixedPosition = context.currentClip;
     } else if (object.objectPaintProperties() && object.objectPaintProperties()->cssClip()) {
         // CSS clip applies to all descendants, even if this object is not a containing block
@@ skipping 25 matching lines @@
         return;
 
     const LayoutBoxModelObject& boxModelObject = toLayoutBoxModelObject(object);
 
     switch (object.styleRef().position()) {
     case StaticPosition:
         break;
     case RelativePosition:
         context.paintOffset += boxModelObject.offsetForInFlowPosition();
         break;
-    case AbsolutePosition:
+    case AbsolutePosition: {
         context.currentTransform = context.transformForAbsolutePosition;
         context.paintOffset = context.paintOffsetForAbsolutePosition;
+
+        // Absolutely positioned content in an inline should be positioned relative to the inline.
+        LayoutObject* container = context.containerForAbsolutePosition;
+        if (container && container->isInFlowPositioned() && container->isLayoutInline()) {
+            DCHECK(object.isBox());
+            context.paintOffset += toLayoutInline(container)->offsetForInFlowPositionedInline(toLayoutBox(object));
+        }
+
         context.currentClip = context.clipForAbsolutePosition;
         break;
+    }
     case StickyPosition:
         context.paintOffset += boxModelObject.offsetForInFlowPosition();
         break;
     case FixedPosition:
         context.currentTransform = context.transformForFixedPosition;
         context.paintOffset = context.paintOffsetForFixedPosition;
         context.currentClip = context.clipForFixedPosition;
         break;
     default:
         ASSERT_NOT_REACHED();
@@ skipping 39 matching lines @@
 
     if (object.isLayoutPart()) {
         Widget* widget = toLayoutPart(object).widget();
         if (widget && widget->isFrameView())
             walk(*toFrameView(widget), localContext);
         // TODO(pdr): Investigate RemoteFrameView (crbug.com/579281).
     }
 }
 
 } // namespace blink