Stop clipping to visual rect bounds in PLC::CalculateBackgroundClipRect

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 187 matching lines @@
          layer = layer->NextSibling())
       layers.push(layer);
   }
 }
 
 LayoutRect PaintLayerClipper::LocalClipRect(
     const PaintLayer& clipping_root_layer) const {
   ClipRectsContext context(&clipping_root_layer, kPaintingClipRects);
   if (use_geometry_mapper_) {
     ClipRect clip_rect;
-    CalculateBackgroundClipRectWithGeometryMapper(context, clip_rect);
+    CalculateBackgroundClipRectWithGeometryMapper(context, clip_rect,
+                                                  ShouldClipOverflow(context));
     LayoutRect premapped_rect = clip_rect.Rect();
 
     // The rect now needs to be transformed to the local space of this
     // PaintLayer.
     premapped_rect.MoveBy(context.root_layer->GetLayoutObject().PaintOffset());
 
     const auto* clip_root_layer_transform =
         clipping_root_layer.GetLayoutObject()
             .LocalBorderBoxProperties()
             ->Transform();
@@ skipping 53 matching lines @@
   else
     layer_.ConvertToLayerCoords(context.root_layer, offset);
   layer_bounds = LayoutRect(offset, LayoutSize(layer_.size()));
 
   // TODO(chrishtr): fix the underlying bug that causes this situation.
   if (!layer_.GetLayoutObject().PaintProperties() &&
       !layer_.GetLayoutObject().LocalBorderBoxProperties()) {
     background_rect = ClipRect(LayoutRect(LayoutRect::InfiniteIntRect()));
     foreground_rect = ClipRect(LayoutRect(LayoutRect::InfiniteIntRect()));
   } else {
-    CalculateBackgroundClipRectWithGeometryMapper(context, background_rect);
+    CalculateBackgroundClipRectWithGeometryMapper(context, background_rect,
+                                                  ShouldClipOverflow(context));
     background_rect.Move(context.sub_pixel_accumulation);
     background_rect.Intersect(paint_dirty_rect);
 
     foreground_rect = background_rect;
 
     LayoutBoxModelObject& layout_object = layer_.GetLayoutObject();
     if (layout_object.HasClip()) {
       LayoutRect new_pos_clip = ToLayoutBox(layout_object).ClipRect(offset);
       foreground_rect.Intersect(new_pos_clip);
     }
@@ skipping 126 matching lines @@
     return parent_rects.FixedClipRect();
 
   if (position == EPosition::kAbsolute)
     return parent_rects.PosClipRect();
 
   return parent_rects.OverflowClipRect();
 }
 
 void PaintLayerClipper::CalculateBackgroundClipRectWithGeometryMapper(
     const ClipRectsContext& context,
-    ClipRect& output) const {
+    ClipRect& output,
+    bool should_clip_to_visual_overflow) const {
   DCHECK(use_geometry_mapper_);
   PropertyTreeState source_property_tree_state(nullptr, nullptr, nullptr);
   PropertyTreeState destination_property_tree_state(nullptr, nullptr, nullptr);
   InitializeCommonClipRectState(context, source_property_tree_state,
                                 destination_property_tree_state);
 
   if (&layer_ != context.root_layer) {
     auto* ancestor_properties =
         context.root_layer->GetLayoutObject().PaintProperties();
     const auto* ancestor_overflow_clip =
@@ skipping 10 matching lines @@
   // of m_layer, because nothing in m_layer or its children within the clip can
   // paint outside of those bounds.
   // The total painting bounds includes any visual overflow (such as shadow) and
   // filter bounds.
   //
   // TODO(chrishtr): sourceToDestinationVisualRect and
   // sourceToDestinationClipRect may not compute tight results in the presence
   // of transforms. Tight results are required for most use cases of these
   // rects, so we should add methods to GeometryMapper that guarantee there
   // are tight results, or else signal an error.
-  if (ShouldClipOverflow(context)) {
+  if (should_clip_to_visual_overflow) {
     FloatClipRect clip_rect((FloatRect(LocalVisualRect())));
     clip_rect.MoveBy(FloatPoint(layer_.GetLayoutObject().PaintOffset()));
     GeometryMapper::SourceToDestinationVisualRect(
         source_property_tree_state, destination_property_tree_state, clip_rect);
     output.SetRect(clip_rect);
   } else {
     const FloatClipRect& clipped_rect_in_root_layer_space =
         GeometryMapper::SourceToDestinationClipRect(
             source_property_tree_state, destination_property_tree_state);
     output.SetRect(clipped_rect_in_root_layer_space);
+    if (clipped_rect_in_root_layer_space.IsInfinite())
+      return;
   }
 
   output.MoveBy(-context.root_layer->GetLayoutObject().PaintOffset());
 }
 
 void PaintLayerClipper::InitializeCommonClipRectState(
     const ClipRectsContext& context,
     PropertyTreeState& source_property_tree_state,
     PropertyTreeState& destination_property_tree_state) const {
   DCHECK(use_geometry_mapper_);
@@ skipping 41 matching lines @@
     const ClipRectsContext& context,
     ClipRect& output) const {
   if (use_geometry_mapper_) {
     // TODO(chrishtr): fix the underlying bug that causes this situation.
     if (!layer_.GetLayoutObject().PaintProperties() &&
         !layer_.GetLayoutObject().LocalBorderBoxProperties()) {
       output.SetRect(FloatClipRect());
       return;
     }
 
-    CalculateBackgroundClipRectWithGeometryMapper(context, output);
+    CalculateBackgroundClipRectWithGeometryMapper(context, output, false);
 #ifdef CHECK_CLIP_RECTS
     ClipRect testBackgroundClipRect =
         PaintLayerClipper(m_layer, nullptr).backgroundClipRect(context);
     CHECK_RECTS_EQ(testBackgroundClipRect, output);
 #endif
     return;
   }
   DCHECK(layer_.Parent());
   LayoutView* layout_view = layer_.GetLayoutObject().View();
   DCHECK(layout_view);
@@ skipping 61 matching lines @@
   DCHECK(!use_geometry_mapper_);
   ClipRectsContext context(root_layer, kPaintingClipRects,
                            kIgnorePlatformOverlayScrollbarSize,
                            subpixel_accumulation);
   if (respect_overflow_clip == kIgnoreOverflowClip)
     context.SetIgnoreOverflowClip();
   return GetClipRects(context);
 }
 
 }  // namespace blink