Remove paintOffsetTranslation for fixed-position elements.

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 403 matching lines @@
       isPaintingOverlayScrollbars) {
     // Collect the fragments. This will compute the clip rectangles and paint
     // offsets for each layer fragment.
     ClipRectsCacheSlot cacheSlot = (paintFlags & PaintLayerUncachedClipRects)
                                        ? UncachedClipRects
                                        : PaintingClipRects;
     // 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 ||
-        RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+        RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       m_paintLayer.appendSingleFragmentIgnoringPagination(
           layerFragments, localPaintingInfo.rootLayer,
           localPaintingInfo.paintDirtyRect, cacheSlot,
           IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot,
           localPaintingInfo.subPixelAccumulation);
-    else
+    } else if (!collectPaintFragmentsForPaginatedFixedPosition(
+                   paintingInfo, layerFragments)) {
       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.
       shouldPaintContent = atLeastOneFragmentIntersectsDamageRect(
           layerFragments, localPaintingInfo, paintFlags, offsetFromRoot);
       if (!shouldPaintContent)
         result = MayBeClippedByPaintDirtyRect;
     }
   }
@@ skipping 136 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(
+    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();
+
+  // 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
+  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();
+
+  for (unsigned i = 0; i < pages; i++) {
+    PaintLayerFragment fragment;
+    fragment.backgroundRect = paintingInfo.paintDirtyRect;
+    fragment.paginationOffset = paginationOffset;
+    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 fragments;
-  // TODO(crbug.com/619094): Figure out the correct behaviour for fixed position
-  // objects in paged media with vertical writing modes.
-  if (isFixedPosObjectInPagedMedia && 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
-    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();
-
-    for (unsigned i = 0; i < pages; i++) {
+  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;
-      fragment.paginationOffset = paginationOffset;
-      fragments.append(fragment);
-      paginationOffset += LayoutPoint(LayoutUnit(), view->pageLogicalHeight());
+      layerFragments.append(fragment);
     }
-  } else 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(
-        fragments, 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;
-    fragments.append(fragment);
   }
 
   Optional<DisplayItemCacheSkipper> cacheSkipper;
-  if (fragments.size() > 1)
+  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 : fragments) {
+  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)
         clipRectForFragment.moveBy(fragment.paginationOffset);
       clipRectForFragment.intersect(fragment.backgroundRect);
       if (clipRectForFragment.isEmpty())
         continue;
@@ skipping 409 matching lines @@
 
   PaintLayerPaintingInfo paintingInfo(&m_paintLayer,
                                       LayoutRect(enclosingIntRect(damageRect)),
                                       paintFlags, LayoutSize());
   paint(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
   m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 }  // namespace blink