[SPInvalidation, SPv2] Compute paint offset for paginated content

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 <memory>
 #include "core/dom/DOMNodeIds.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 186 matching lines @@
 
   // Initialize the context for current, absolute and fixed position cases.
   // They are the same, except that scroll translation does not apply to
   // fixed position descendants.
   const auto* fixed_transform_node = frame_view.PreTranslation()
                                          ? frame_view.PreTranslation()
                                          : context.current.transform;
   auto* fixed_scroll_node = context.current.scroll;
   DCHECK(frame_view.PreTranslation());
   context.current.transform = frame_view.PreTranslation();
+  context.current.transform_paint_layer = frame_view.GetLayoutView()->Layer();
   DCHECK(frame_view.ContentClip());
   context.current.clip = frame_view.ContentClip();
   if (const auto* scroll_translation = frame_view.ScrollTranslation()) {
     context.current.transform = scroll_translation;
     context.current.scroll = scroll_translation->ScrollNode();
   }
   context.current.paint_offset = LayoutPoint();
   context.current.rendering_context_id = 0;
   context.current.should_flatten_inherited_transform = true;
   context.absolute_position = context.current;
@@ skipping 42 matching lines @@
 
   auto& properties = object.GetMutableForPainting().EnsurePaintProperties();
   context.force_subtree_update |= properties.UpdatePaintOffsetTranslation(
       context.current.transform,
       TransformationMatrix().Translate(rounded_paint_offset.X(),
                                        rounded_paint_offset.Y()),
       FloatPoint3D(), context.current.should_flatten_inherited_transform,
       context.current.rendering_context_id);
 
   context.current.transform = properties.PaintOffsetTranslation();
+  context.current.transform_paint_layer = object.Layer();
+
   context.current.paint_offset = fractional_paint_offset;
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
       object.IsLayoutView()) {
     context.absolute_position.transform = properties.PaintOffsetTranslation();
+    context.absolute_position.transform_paint_layer = object.Layer();
     context.fixed_position.transform = properties.PaintOffsetTranslation();
+    context.fixed_position.transform_paint_layer = object.Layer();
     context.absolute_position.paint_offset = LayoutPoint();
     context.fixed_position.paint_offset = LayoutPoint();
   }
 }
 
 // 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) {
@@ skipping 16 matching lines @@
           context.current.transform, TransformationMatrix(transform),
           FloatPoint3D());
     } else {
       if (auto* properties = object.GetMutableForPainting().PaintProperties())
         context.force_subtree_update |= properties->ClearTransform();
     }
   }
 
   if (object.PaintProperties() && object.PaintProperties()->Transform()) {
     context.current.transform = object.PaintProperties()->Transform();
+    context.current.transform_paint_layer = nullptr;
     context.current.should_flatten_inherited_transform = false;
     context.current.rendering_context_id = 0;
   }
 }
 
 static CompositingReasons CompositingReasonsForTransform(const LayoutBox& box) {
   const ComputedStyle& style = box.StyleRef();
   CompositingReasons compositing_reasons = kCompositingReasonNone;
   if (CompositingReasonFinder::RequiresCompositingForTransform(box))
     compositing_reasons |= kCompositingReason3DTransform;
@@ skipping 81 matching lines @@
     }
     if (!has_transform) {
       if (auto* properties = object.GetMutableForPainting().PaintProperties())
         context.force_subtree_update |= properties->ClearTransform();
     }
   }
 
   const auto* properties = object.PaintProperties();
   if (properties && properties->Transform()) {
     context.current.transform = properties->Transform();
+    if (object.IsBoxModelObject()) {
+      context.current.transform_paint_layer =
+          ToLayoutBoxModelObject(object).Layer();
+    }
     if (object.StyleRef().Preserves3D()) {
       context.current.rendering_context_id =
           properties->Transform()->RenderingContextId();
       context.current.should_flatten_inherited_transform = false;
     } else {
       context.current.rendering_context_id = 0;
       context.current.should_flatten_inherited_transform = true;
     }
   }
 }
@@ skipping 390 matching lines @@
           context.current.rendering_context_id);
     } else {
       if (auto* properties = object.GetMutableForPainting().PaintProperties())
         context.force_subtree_update |= properties->ClearPerspective();
     }
   }
 
   const auto* properties = object.PaintProperties();
   if (properties && properties->Perspective()) {
     context.current.transform = properties->Perspective();
+    if (object.IsBoxModelObject()) {
+      context.current.transform_paint_layer =
+          ToLayoutBoxModelObject(object).Layer();
+    }
     context.current.should_flatten_inherited_transform = false;
   }
 }
 
 void PaintPropertyTreeBuilder::UpdateSvgLocalToBorderBoxTransform(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.IsSVGRoot())
     return;
 
@@ skipping 11 matching lines @@
       if (auto* properties = object.GetMutableForPainting().PaintProperties()) {
         context.force_subtree_update |=
             properties->ClearSvgLocalToBorderBoxTransform();
       }
     }
   }
 
   const auto* properties = object.PaintProperties();
   if (properties && properties->SvgLocalToBorderBoxTransform()) {
     context.current.transform = properties->SvgLocalToBorderBoxTransform();
+    if (object.IsBoxModelObject()) {
+      context.current.transform_paint_layer =
+          ToLayoutBoxModelObject(object).Layer();
+    }
     context.current.should_flatten_inherited_transform = false;
     context.current.rendering_context_id = 0;
   }
   // The paint offset is included in |transformToBorderBox| so SVG does not need
   // to handle paint offset internally.
   context.current.paint_offset = LayoutPoint();
 }
 
 static MainThreadScrollingReasons GetMainThreadScrollingReasons(
     const LayoutObject& object,
@@ skipping 63 matching lines @@
     if (!needs_scroll_properties) {
       // Ensure pre-existing properties are cleared.
       if (auto* properties = object.GetMutableForPainting().PaintProperties())
         context.force_subtree_update |= properties->ClearScrollTranslation();
     }
   }
 
   if (object.PaintProperties() &&
       object.PaintProperties()->ScrollTranslation()) {
     context.current.transform = object.PaintProperties()->ScrollTranslation();
+    if (object.IsBoxModelObject()) {
+      context.current.transform_paint_layer =
+          ToLayoutBoxModelObject(object).Layer();
+    }
     context.current.scroll = context.current.transform->ScrollNode();
     context.current.should_flatten_inherited_transform = false;
   }
 }
 
 void PaintPropertyTreeBuilder::UpdateOutOfFlowContext(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.IsLayoutBlock())
     context.paint_offset_for_float = context.current.paint_offset;
 
   if (object.CanContainAbsolutePositionObjects()) {
     context.absolute_position = context.current;
     context.container_for_absolute_position = &object;
   }
 
   if (object.IsLayoutView()) {
     if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       const auto* initial_fixed_transform = context.fixed_position.transform;
+      const auto* initial_fixed_transform_paint_layer =
+          context.fixed_position.transform_paint_layer;
       const auto* initial_fixed_scroll = context.fixed_position.scroll;
 
       context.fixed_position = context.current;
 
       // Fixed position transform and scroll nodes should not be affected.
       context.fixed_position.transform = initial_fixed_transform;
+      context.fixed_position.transform_paint_layer =
+          initial_fixed_transform_paint_layer;
       context.fixed_position.scroll = initial_fixed_scroll;
     }
   } else if (object.CanContainFixedPositionObjects()) {
     context.fixed_position = context.current;
   } else if (object.GetMutableForPainting().PaintProperties() &&
              object.PaintProperties()->CssClip()) {
     // CSS clip applies to all descendants, even if this object is not a
     // containing block ancestor of the descendant. It is okay for
     // absolute-position descendants because having CSS clip implies being
     // absolute position container. However for fixed-position descendants we
@@ skipping 81 matching lines @@
     // This is a weird quirk that table cells paint as children of table rows,
     // but their location have the row's location baked-in.
     // Similar adjustment is done in LayoutTableCell::offsetFromContainer().
     if (object.IsTableCell()) {
       LayoutObject* parent_row = object.Parent();
       DCHECK(parent_row && parent_row->IsTableRow());
       context.current.paint_offset.MoveBy(
           -ToLayoutBox(parent_row)->PhysicalLocation());
     }
   }
+
+  // In the presence of pagination, recompute from scratch the paint offset.
+  // The paint offset for a fragmented LayoutObject is the top-left of its
+  // position in the first fragment in which it participates. See
+  // crbug.com/648274.
+  if (PaintLayer* paint_layer = object.PaintingLayer()) {
+    if (paint_layer->EnclosingPaginationLayer()) {
+      LayoutPoint local_offset = ToLayoutPoint(
+          object.OffsetFromAncestorContainer(&paint_layer->GetLayoutObject()));
+      DCHECK(context.current.transform_paint_layer);
+      context.current.paint_offset = paint_layer->VisualOffsetFromAncestor(
+          context.current.transform_paint_layer, local_offset);
+    }
+  }
 }
 
 void PaintPropertyTreeBuilder::UpdateForObjectLocationAndSize(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
 #if DCHECK_IS_ON()
   FindPaintOffsetNeedingUpdateScope check_scope(object, context);
 #endif
 
   if (object.IsBoxModelObject()) {
@@ skipping 86 matching lines @@
   UpdateOverflowClip(object, context);
   UpdatePerspective(object, context);
   UpdateSvgLocalToBorderBoxTransform(object, context);
   UpdateScrollAndScrollTranslation(object, context);
   UpdateOutOfFlowContext(object, context);
 
   context.force_subtree_update |= object.SubtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink