"Inline" auto-positioned out-of-flow objects are affected by pagination struts.

third_party/WebKit/Source/core/layout/LayoutBlockFlowLine.cpp

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 855 matching lines @@
         if (resolver.position().atEnd()) {
             // FIXME: We shouldn't be creating any runs in nextLineBreak to begin with!
             // Once BidiRunList is separated from BidiResolver this will not be needed.
             resolver.runs().deleteRuns();
             resolver.markCurrentRunEmpty(); // FIXME: This can probably be replaced by an ASSERT (or just removed).
             resolver.setPosition(InlineIterator(resolver.position().root(), 0, 0), 0);
             break;
         }
 
         ASSERT(endOfLine != resolver.position());
+        RootInlineBox* lineBox = nullptr;
 
         // This is a short-cut for empty lines.
         if (layoutState.lineInfo().isEmpty()) {
             ASSERT(!paginationStrutFromDeletedLine);
             if (lastRootBox())
                 lastRootBox()->setLineBreakInfo(endOfLine.getLineLayoutItem(), endOfLine.offset(), resolver.status());
             resolver.runs().deleteRuns();
         } else {
             VisualDirectionOverride override = (styleToUse.rtlOrdering() == VisualOrder ? (styleToUse.direction() == LTR ? VisualLeftToRightOverride : VisualRightToLeftOverride) : NoVisualOverride);
             if (isNewUBAParagraph && styleToUse.unicodeBidi() == Plaintext && !resolver.context()->parent()) {
                 TextDirection direction = determinePlaintextDirectionality(resolver.position().root(), resolver.position().getLineLayoutItem(), resolver.position().offset());
                 resolver.setStatus(BidiStatus(direction, isOverride(styleToUse.unicodeBidi())));
             }
             // FIXME: This ownership is reversed. We should own the BidiRunList and pass it to createBidiRunsForLine.
             BidiRunList<BidiRun>& bidiRuns = resolver.runs();
             constructBidiRunsForLine(resolver, bidiRuns, endOfLine, override, layoutState.lineInfo().previousLineBrokeCleanly(), isNewUBAParagraph);
             ASSERT(resolver.position() == endOfLine);
 
             BidiRun* trailingSpaceRun = resolver.trailingSpaceRun();
 
             if (bidiRuns.runCount() && lineBreaker.lineWasHyphenated())
                 bidiRuns.logicallyLastRun()->m_hasHyphen = true;
 
             // Now that the runs have been ordered, we create the line boxes.
             // At the same time we figure out where border/padding/margin should be applied for
             // inline flow boxes.
 
             LayoutUnit oldLogicalHeight = logicalHeight();
-            RootInlineBox* lineBox = createLineBoxesFromBidiRuns(resolver.status().context->level(), bidiRuns, endOfLine, layoutState.lineInfo(), verticalPositionCache, trailingSpaceRun, wordMeasurements);
+            lineBox = createLineBoxesFromBidiRuns(resolver.status().context->level(), bidiRuns, endOfLine, layoutState.lineInfo(), verticalPositionCache, trailingSpaceRun, wordMeasurements);
 
             bidiRuns.deleteRuns();
             resolver.markCurrentRunEmpty(); // FIXME: This can probably be replaced by an ASSERT (or just removed).
 
             // If we decided to re-create the line due to pagination, we better have a new line now.
             ASSERT(lineBox || !paginationStrutFromDeletedLine);
 
             if (lineBox) {
                 lineBox->setLineBreakInfo(endOfLine.getLineLayoutItem(), endOfLine.offset(), resolver.status());
                 if (paginated) {
@@ skipping 24 matching lines @@
                             } else {
                                 setLogicalHeight(lineBox->lineBottomWithLeading());
                             }
                         }
                     }
                 }
             }
         }
 
         if (!paginationStrutFromDeletedLine) {
-            for (size_t i = 0; i < lineBreaker.positionedObjects().size(); ++i)
-                setStaticPositions(LineLayoutBlockFlow(this), LineLayoutBox(lineBreaker.positionedObjects()[i]), DoNotIndentText);
+            for (const auto& positionedObject : lineBreaker.positionedObjects()) {
+                if (positionedObject.style()->isOriginalDisplayInlineType()) {
+                    // Auto-positioend "inline" out-of-flow objects have already been positioned,
+                    // but if we're paginated, we need to update their position now, since the line
+                    // they "belong" to may have been pushed by a pagination strut.
+                    if (paginated && lineBox)
+                        positionedObject.layer()->setStaticBlockPosition(lineBox->lineTopWithLeading());
+                    continue;
+                }
+                setStaticPositions(LineLayoutBlockFlow(this), positionedObject, DoNotIndentText);
+            }
 
             if (!layoutState.lineInfo().isEmpty())
                 layoutState.lineInfo().setFirstLine(false);
             clearFloats(lineBreaker.clear());
 
             if (m_floatingObjects && lastRootBox()) {
                 InlineBidiResolver endOfLineResolver;
                 endOfLineResolver.setPosition(endOfLine, numberOfIsolateAncestors(endOfLine));
                 endOfLineResolver.setStatus(resolver.status());
                 appendFloatsToLastLine(layoutState, cleanLineStart, endOfLineResolver, cleanLineBidiStatus);
@@ skipping 1118 matching lines @@
 
 PaintInvalidationReason LayoutBlockFlow::invalidatePaintIfNeeded(const PaintInvalidationState& paintInvalidationState)
 {
     if (containsFloats())
         paintInvalidationState.paintingLayer().setNeedsPaintPhaseFloat();
 
     return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 } // namespace blink