Always report maybe-clipped when painting fragmented content

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 452 matching lines @@
           local_painting_info.sub_pixel_accumulation);
       RepeatFixedPositionObjectInPages(single_fragment[0], painting_info,
                                        layer_fragments);
     } else {
       paint_layer_for_fragments->CollectFragments(
           layer_fragments, local_painting_info.root_layer,
           local_painting_info.paint_dirty_rect, cache_slot,
           geometry_mapper_option, kIgnorePlatformOverlayScrollbarSize,
           respect_overflow_clip, &offset_from_root,
           local_painting_info.sub_pixel_accumulation);
+      // PaintLayer::collectFragments depends on the paint dirty rect in
+      // complicated ways. For now, always assume a partially painted output
+      // for fragmented content.
+      if (layer_fragments.size() > 1)
+        result = kMayBeClippedByPaintDirtyRect;
     }
 
     if (paint_flags & kPaintLayerPaintingAncestorClippingMaskPhase) {
       // Fragment offsets have been computed in the clipping container's
       // layer's coordinate system, but for the rest of painting we need
       // them in the layer coordinate. So move them and the foreground rect
       // that is also in the clipper's space.
       LayoutSize negative_offset(-offset_to_clipper.X(),
                                  -offset_to_clipper.Y());
       for (auto& fragment : layer_fragments) {
@@ skipping 207 matching lines @@
   // 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* parent_layer = paint_layer_.Parent();
 
   PaintLayer::GeometryMapperOption geometry_mapper_option =
       PaintLayer::kDoNotUseGeometryMapper;
   if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
     geometry_mapper_option = PaintLayer::kUseGeometryMapper;
 
+  PaintResult result = kFullyPainted;
   PaintLayer* pagination_layer = paint_layer_.EnclosingPaginationLayer();
   PaintLayerFragments layer_fragments;
   bool is_fixed_position_object_in_paged_media =
       this->IsFixedPositionObjectInPagedMedia();
   if (!pagination_layer || is_fixed_position_object_in_paged_media) {
     // 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;
@@ skipping 22 matching lines @@
         painting_info.GetGlobalPaintFlags());
 
     // FIXME: we don't check if paginationLayer is within
     // paintingInfo.rootLayer
     // here.
     pagination_layer->CollectFragments(
         layer_fragments, painting_info.root_layer,
         painting_info.paint_dirty_rect, cache_slot, geometry_mapper_option,
         kIgnorePlatformOverlayScrollbarSize, respect_overflow_clip, nullptr,
         painting_info.sub_pixel_accumulation, &transformed_extent);
+    // PaintLayer::collectFragments depends on the paint dirty rect in
+    // complicated ways. For now, always assume a partially painted output
+    // for fragmented content.
+    if (layer_fragments.size() > 1)
+      result = kMayBeClippedByPaintDirtyRect;
   }
 
   Optional<DisplayItemCacheSkipper> cache_skipper;
   if (layer_fragments.size() > 1)
     cache_skipper.emplace(context);
 
   ClipRect ancestor_background_clip_rect;
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     if (parent_layer) {
       // Calculate the clip rectangle that the ancestors establish.
       ClipRectsContext clip_rects_context(
           painting_info.root_layer,
           (paint_flags & kPaintLayerUncachedClipRects) ? kUncachedClipRects
                                                        : kPaintingClipRects,
           kIgnorePlatformOverlayScrollbarSize);
       if (ShouldRespectOverflowClip(paint_flags,
                                     paint_layer_.GetLayoutObject()) ==
           kIgnoreOverflowClip)
         clip_rects_context.SetIgnoreOverflowClip();
       paint_layer_.Clipper(geometry_mapper_option)
           .CalculateBackgroundClipRect(clip_rects_context,
                                        ancestor_background_clip_rect);
     }
   }
 
-  PaintResult result = kFullyPainted;
   for (const auto& fragment : layer_fragments) {
     Optional<LayerClipRecorder> clip_recorder;
     if (parent_layer && !RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       ClipRect clip_rect_for_fragment(ancestor_background_clip_rect);
       // A fixed-position object is repeated on every page instead of paginated,
       // so we should apply the original ancestor clip rect.
       if (!is_fixed_position_object_in_paged_media)
         clip_rect_for_fragment.MoveBy(fragment.pagination_offset);
       clip_rect_for_fragment.Intersect(fragment.background_rect);
       if (clip_rect_for_fragment.IsEmpty())
@@ skipping 440 matching lines @@
           context, layout_object, kPaintPhaseClippingMask))
     return;
 
   IntRect snapped_clip_rect = PixelSnappedIntRect(clip_rect.Rect());
   LayoutObjectDrawingRecorder drawing_recorder(
       context, layout_object, kPaintPhaseClippingMask, snapped_clip_rect);
   context.FillRect(snapped_clip_rect, Color::kBlack);
 }
 
 }  // namespace blink