[SPInvalidation] Fix fixed-position printing

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

 // Copyright 2014 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/PaintLayerPainter.h"
 
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
 #include "core/paint/FilterPainter.h"
@@ skipping 394 matching lines @@
                             isSelfPaintingLayer && !isPaintingOverlayScrollbars;
 
   PaintLayerFragments layerFragments;
   if (shouldPaintContent || shouldPaintSelfOutline ||
       isPaintingOverlayScrollbars) {
     // Collect the fragments. This will compute the clip rectangles and paint
     // offsets for each layer fragment.
     ClipRectsCacheSlot cacheSlot = (paintFlags & PaintLayerUncachedClipRects)
                                        ? UncachedClipRects
                                        : PaintingClipRects;
+    bool isFixedPositionObjectInPagedMedia =
+        fragmentPolicy != ForceSingleFragment &&
+        this->isFixedPositionObjectInPagedMedia();
     // TODO(trchen): We haven't decided how to handle visual fragmentation with
     // SPv2.  Related thread
     // https://groups.google.com/a/chromium.org/forum/#!topic/graphics-dev/81XuWFf-mxM
     if (fragmentPolicy == ForceSingleFragment ||
+        isFixedPositionObjectInPagedMedia ||
         RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       m_paintLayer.appendSingleFragmentIgnoringPagination(
           layerFragments, localPaintingInfo.rootLayer,
           localPaintingInfo.paintDirtyRect, cacheSlot,
           IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot,
           localPaintingInfo.subPixelAccumulation);
-    } else if (!collectPaintFragmentsForPaginatedFixedPosition(
-                   paintingInfo, layerFragments)) {
+      if (isFixedPositionObjectInPagedMedia)
+        repeatFixedPositionObjectInPages(paintingInfo, layerFragments);

[chrishtr, 2016/12/30 00:10:50]

It's only possible in single-fragment mode?

[Xianzhu, 2016/12/30 00:52:41]

Now isFixedPositionObjectInPageMedia and single-fragment mode share the same
code between line 424 and 428. For isFixedPositionObjectInPageMedia, the shared
code generates the first fragment for the fixed-position object, then the above
function call repeats and adjusts the fragment for each page.

In paintLayerWithTransform path, this function is called with
ForceSingleFragment from the fragment iteration loop in paintLayerWithTransform,
and isFixedPositionObjectInPagedMedia variable is set to false, and we won't
generate fragments again.

+    } else {
       m_paintLayer.collectFragments(layerFragments, localPaintingInfo.rootLayer,
                                     localPaintingInfo.paintDirtyRect, cacheSlot,
                                     IgnoreOverlayScrollbarSize,
                                     respectOverflowClip, &offsetFromRoot,
                                     localPaintingInfo.subPixelAccumulation);
     }
 
     if (shouldPaintContent) {
       // TODO(wangxianzhu): This is for old slow scrolling. Implement similar
       // optimization for slimming paint v2.
@@ skipping 142 matching lines @@
     // fragment.layerBounds is set to the border box, not the bounding box, of
     // the layer.
     if (m_paintLayer.intersectsDamageRect(fragment.layerBounds,
                                           fragment.backgroundRect.rect(),
                                           newOffsetFromRoot))
       return true;
   }
   return false;
 }
 
-bool PaintLayerPainter::collectPaintFragmentsForPaginatedFixedPosition(
+inline bool PaintLayerPainter::isFixedPositionObjectInPagedMedia() {
+  LayoutObject* object = m_paintLayer.layoutObject();
+  LayoutView* view = object->view();
+  return object->styleRef().position() == FixedPosition &&
+         object->container() == view && view->pageLogicalHeight() &&
+         // TODO(crbug.com/619094): Figure out the correct behaviour for fixed
+         // position objects in paged media with vertical writing modes.
+         view->isHorizontalWritingMode();
+}
+
+// "For paged media, boxes with fixed positions are repeated on every page."
+// https://www.w3.org/TR/2011/REC-CSS2-20110607/visuren.html#fixed-positioning
+void PaintLayerPainter::repeatFixedPositionObjectInPages(
     const PaintLayerPaintingInfo& paintingInfo,
     PaintLayerFragments& layerFragments) {
-  LayoutObject* object = m_paintLayer.layoutObject();
-  LayoutView* view = object->view();
-  bool isFixedPosObjectInPagedMedia =
-      object->style()->position() == FixedPosition &&
-      object->container() == view && view->pageLogicalHeight();
+  DCHECK(isFixedPositionObjectInPagedMedia());
+  DCHECK_EQ(1u, layerFragments.size());
 
-  // TODO(crbug.com/619094): Figure out the correct behaviour for fixed position
-  // objects in paged media with vertical writing modes.
-  if (!isFixedPosObjectInPagedMedia || !view->isHorizontalWritingMode())
-    return false;
-
-  // "For paged media, boxes with fixed positions are repeated on every page."
-  // https://www.w3.org/TR/2011/REC-CSS2-20110607/visuren.html#fixed-positioning
+  LayoutView* view = m_paintLayer.layoutObject()->view();
   unsigned pages =
       ceilf(view->documentRect().height() / view->pageLogicalHeight());
-  LayoutPoint paginationOffset;
 
   // The fixed position object is offset from the top of the page, so remove
   // any scroll offset.
   LayoutPoint offsetFromRoot;
   m_paintLayer.convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot);
-  paginationOffset -= offsetFromRoot - m_paintLayer.location();
+  LayoutSize offsetAdjustment = m_paintLayer.location() - offsetFromRoot;
+  layerFragments[0].paginationOffset += offsetAdjustment;
+  layerFragments[0].layerBounds.move(offsetAdjustment);
 
-  for (unsigned i = 0; i < pages; i++) {
-    PaintLayerFragment fragment;
-    fragment.backgroundRect = paintingInfo.paintDirtyRect;
-    fragment.paginationOffset = paginationOffset;
+  LayoutPoint pageOffset(LayoutUnit(), view->pageLogicalHeight());
+  for (unsigned i = 1; i < pages; i++) {
+    PaintLayerFragment fragment = layerFragments[i - 1];

[chrishtr, 2017/01/03 18:25:09]

What guarantees that |layerFragments| has exactly the same length
as |pages|? The previous code didn't have this dependency...

[chrishtr, 2017/01/03 18:53:10]

oh I see now, nm.

+    fragment.paginationOffset += pageOffset;
+    fragment.layerBounds.moveBy(pageOffset);

[chrishtr, 2016/12/30 00:10:50]

This didn't used to get set in the transformed path. Was it a bug there also?

[Xianzhu, 2016/12/30 00:52:41]

No. layerBounds and foregroundRect of these fragments are not used in
transformed path. This is why we only have had problem since we switched to
non-transformed path. Foreground clipping is applied in single-fragment mode
down the path later.

[chrishtr, 2017/01/03 18:25:09]

I'm not sure what you mean. layerBounds is used in
atLeastOneFragmentIntersectsDamageRect and paintFragmentWithPhase.
Don't those get called in the transformed path?

[chrishtr, 2017/01/03 18:53:10]

Right ok, now I see.

     layerFragments.append(fragment);
-    paginationOffset += LayoutPoint(LayoutUnit(), view->pageLogicalHeight());
   }
-  return true;
 }
 
 PaintResult PaintLayerPainter::paintLayerWithTransform(
     GraphicsContext& context,
     const PaintLayerPaintingInfo& paintingInfo,
     PaintLayerFlags paintFlags) {
   TransformationMatrix layerTransform =
       m_paintLayer.renderableTransform(paintingInfo.getGlobalPaintFlags());
   // If the transform can't be inverted, then don't paint anything.
   if (!layerTransform.isInvertible())
     return FullyPainted;
 
   // FIXME: We should make sure that we don't walk past paintingInfo.rootLayer
   // here.  m_paintLayer may be the "root", and then we should avoid looking at
   // its parent.
   PaintLayer* parentLayer = m_paintLayer.parent();
 
-  LayoutObject* object = m_paintLayer.layoutObject();
-  LayoutView* view = object->view();
-  bool isFixedPosObjectInPagedMedia =
-      object->style()->position() == FixedPosition &&
-      object->container() == view && view->pageLogicalHeight();
   PaintLayer* paginationLayer = m_paintLayer.enclosingPaginationLayer();
   PaintLayerFragments layerFragments;
-  if (!collectPaintFragmentsForPaginatedFixedPosition(paintingInfo,
-                                                      layerFragments)) {
-    if (paginationLayer) {
-      // FIXME: This is a mess. Look closely at this code and the code in Layer
-      // and fix any issues in it & refactor to make it obvious from code
-      // structure what it does and that it's correct.
-      ClipRectsCacheSlot cacheSlot = (paintFlags & PaintLayerUncachedClipRects)
-                                         ? UncachedClipRects
-                                         : PaintingClipRects;
-      ShouldRespectOverflowClipType respectOverflowClip =
-          shouldRespectOverflowClip(paintFlags, m_paintLayer.layoutObject());
-      // Calculate the transformed bounding box in the current coordinate space,
-      // to figure out which fragmentainers (e.g. columns) we need to visit.
-      LayoutRect transformedExtent = PaintLayer::transparencyClipBox(
-          &m_paintLayer, paginationLayer,
-          PaintLayer::PaintingTransparencyClipBox,
-          PaintLayer::RootOfTransparencyClipBox,
-          paintingInfo.subPixelAccumulation,
-          paintingInfo.getGlobalPaintFlags());
-      // FIXME: we don't check if paginationLayer is within
-      // paintingInfo.rootLayer
-      // here.
-      paginationLayer->collectFragments(
-          layerFragments, paintingInfo.rootLayer, paintingInfo.paintDirtyRect,
-          cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, 0,
-          paintingInfo.subPixelAccumulation, &transformedExtent);
-    } else {
-      // We don't need to collect any fragments in the regular way here. We have
-      // already calculated a clip rectangle for the ancestry if it was needed,
-      // and clipping this layer is something that can be done further down the
-      // path, when the transform has been applied.
-      PaintLayerFragment fragment;
-      fragment.backgroundRect = paintingInfo.paintDirtyRect;
-      layerFragments.append(fragment);
-    }
+  bool isFixedPositionObjectInPagedMedia =
+      this->isFixedPositionObjectInPagedMedia();
+  if (!paginationLayer || isFixedPositionObjectInPagedMedia) {
+    // We don't need to collect any fragments in the regular way here. We have
+    // already calculated a clip rectangle for the ancestry if it was needed,
+    // and clipping this layer is something that can be done further down the
+    // path, when the transform has been applied.
+    PaintLayerFragment fragment;
+    fragment.backgroundRect = paintingInfo.paintDirtyRect;
+    layerFragments.append(fragment);
+    if (isFixedPositionObjectInPagedMedia)
+      repeatFixedPositionObjectInPages(paintingInfo, layerFragments);
+  } else {
+    // FIXME: This is a mess. Look closely at this code and the code in Layer
+    // and fix any issues in it & refactor to make it obvious from code
+    // structure what it does and that it's correct.
+    ClipRectsCacheSlot cacheSlot = (paintFlags & PaintLayerUncachedClipRects)
+                                       ? UncachedClipRects
+                                       : PaintingClipRects;
+    ShouldRespectOverflowClipType respectOverflowClip =
+        shouldRespectOverflowClip(paintFlags, m_paintLayer.layoutObject());
+    // Calculate the transformed bounding box in the current coordinate space,
+    // to figure out which fragmentainers (e.g. columns) we need to visit.
+    LayoutRect transformedExtent = PaintLayer::transparencyClipBox(
+        &m_paintLayer, paginationLayer, PaintLayer::PaintingTransparencyClipBox,
+        PaintLayer::RootOfTransparencyClipBox,
+        paintingInfo.subPixelAccumulation, paintingInfo.getGlobalPaintFlags());
+    // FIXME: we don't check if paginationLayer is within
+    // paintingInfo.rootLayer
+    // here.
+    paginationLayer->collectFragments(
+        layerFragments, paintingInfo.rootLayer, paintingInfo.paintDirtyRect,
+        cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, 0,
+        paintingInfo.subPixelAccumulation, &transformedExtent);
   }
 
   Optional<DisplayItemCacheSkipper> cacheSkipper;
   if (layerFragments.size() > 1)
     cacheSkipper.emplace(context);
 
   ClipRect ancestorBackgroundClipRect;
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     if (parentLayer) {
       // Calculate the clip rectangle that the ancestors establish.
       ClipRectsContext clipRectsContext(
           paintingInfo.rootLayer,
           (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects
                                                      : PaintingClipRects,
           IgnoreOverlayScrollbarSize);
       if (shouldRespectOverflowClip(paintFlags, m_paintLayer.layoutObject()) ==
           IgnoreOverflowClip)
         clipRectsContext.setIgnoreOverflowClip();
       ancestorBackgroundClipRect =
           m_paintLayer.clipper().backgroundClipRect(clipRectsContext);
     }
   }
 
   PaintResult result = FullyPainted;
   for (const auto& fragment : layerFragments) {
     Optional<LayerClipRecorder> clipRecorder;
     if (parentLayer && !RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       ClipRect clipRectForFragment(ancestorBackgroundClipRect);
-      // A fixed-position object is repeated on every page, but if it is clipped
-      // by an ancestor layer then the repetitions are clipped out.
-      if (!isFixedPosObjectInPagedMedia)
+      // A fixed-position object is repeated on every page instead of paginated,
+      // so we should apply the original ancestor clip rect.
+      if (!isFixedPositionObjectInPagedMedia)
         clipRectForFragment.moveBy(fragment.paginationOffset);
       clipRectForFragment.intersect(fragment.backgroundRect);
       if (clipRectForFragment.isEmpty())
         continue;
       if (needsToClip(paintingInfo, clipRectForFragment)) {
         clipRecorder.emplace(context, *parentLayer->layoutObject(),
                              DisplayItem::kClipLayerParent, clipRectForFragment,
                              &paintingInfo, fragment.paginationOffset,
                              paintFlags);
       }
@@ skipping 396 matching lines @@
 
   PaintLayerPaintingInfo paintingInfo(&m_paintLayer,
                                       LayoutRect(enclosingIntRect(damageRect)),
                                       paintFlags, LayoutSize());
   paint(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
   m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 }  // namespace blink