[blink] Unify PaintLayerClipper behavior with kIgnoreOverflowClip

Prior to this CL, the behavior of GeometryMapper version and non-GM
version of PaintLayerClipper was inconsistent with kIgnoreOverflowClip
when both CSS clip and overflow clip present on the painting root.

       | CSS clip | Overflow clip | Both
-------+----------+---------------+--------
GM     | Applied  | Skipped       | Skipped
Non-GM | Applied  | Skipped       | Applied

Also the GM-version applies only CSS clip when both present and
context.root_layer == layer_. (While non-GM applies both)

This CL changes the behavior so that both CSS clip and overflow clip are
ignored whether both or either one present. It is believed that it will
also fix a bug that prevented us from enabling impl-side scrolling on
scrollers that has CSS clip.
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2

Review-Url: https://codereview.chromium.org/2856373002
Cr-Commit-Position: refs/heads/master@{#469449}

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

@@ -53,6 +53,25 @@
 
 namespace blink {
 
+static bool HasOverflowClip(
+    const PaintLayer& layer) {
+  if (!layer.GetLayoutObject().IsBox())
+    return false;
+  const LayoutBox& box = ToLayoutBox(layer.GetLayoutObject());
+  return box.ShouldClipOverflow();
+}
+
+bool ClipRectsContext::ShouldRespectRootLayerClip() const {
+  if (respect_overflow_clip == kIgnoreOverflowClip)
+    return false;
+
+  if (root_layer->IsRootLayer() &&
+      respect_overflow_clip_for_viewport == kIgnoreOverflowClip)
+    return false;
+
+  return true;
+}
+
 static void AdjustClipRectsForChildren(
     const LayoutBoxModelObject& layout_object,
     ClipRects& clip_rects) {
@@ -386,6 +405,13 @@ void PaintLayerClipper::CalculateClipRects(const ClipRectsContext& context,
 
   bool is_clipping_root = &layer_ == context.root_layer;
 
+  if (is_clipping_root && !context.ShouldRespectRootLayerClip()) {
+    clip_rects.Reset(LayoutRect(LayoutRect::InfiniteIntRect()));
+    if (layout_object.StyleRef().GetPosition() == EPosition::kFixed)
+      clip_rects.SetFixed(true);
+    return;
+  }
+
   // For transformed layers, the root layer was shifted to be us, so there is no
   // need to examine the parent. We want to cache clip rects with us as the
   // root.
@@ -401,7 +427,9 @@ void PaintLayerClipper::CalculateClipRects(const ClipRectsContext& context,
 
   AdjustClipRectsForChildren(layout_object, clip_rects);
 
-  if (ShouldClipOverflow(context) || layout_object.HasClip()) {
+  // Computing paint offset is expensive, skip the computation if the object
+  // is known to have no clip. This check is redundant otherwise.
+  if (HasOverflowClip(layer_) || layout_object.HasClip()) {
     // This offset cannot use convertToLayerCoords, because sometimes our
     // rootLayer may be across some transformed layer boundary, for example, in
     // the PaintLayerCompositor overlapMap, where clipRects are needed in view
@@ -428,23 +456,18 @@ void PaintLayerClipper::CalculateBackgroundClipRectWithGeometryMapper(
     const ClipRectsContext& context,
     ClipRect& output) const {
   DCHECK(use_geometry_mapper_);
+
+  bool is_clipping_root = &layer_ == context.root_layer;
+  if (is_clipping_root && !context.ShouldRespectRootLayerClip()) {
+    output.SetRect(FloatClipRect());
+    return;
+  }
+
   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 =
-        ancestor_properties ? ancestor_properties->OverflowClip() : nullptr;
-    // Set the clip of |destinationPropertyTreeState| to be inside the
-    // ancestor's overflow clip, so that that clip is not applied.
-    if (context.respect_overflow_clip == kIgnoreOverflowClip &&
-        ancestor_overflow_clip)
-      destination_property_tree_state.SetClip(ancestor_overflow_clip);
-  }
-
   // The background rect applies all clips *above* m_layer, but not the overflow
   // clip of m_layer. It also applies a clip to the total painting bounds
   // of m_layer, because nothing in m_layer or its children within the clip can
@@ -457,7 +480,7 @@ void PaintLayerClipper::CalculateBackgroundClipRectWithGeometryMapper(
   // 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 (HasOverflowClip(layer_)) {
     FloatClipRect clip_rect((FloatRect(LocalVisualRect())));
     clip_rect.MoveBy(FloatPoint(layer_.GetLayoutObject().PaintOffset()));
     GeometryMapper::SourceToDestinationVisualRect(
@@ -478,23 +501,34 @@ void PaintLayerClipper::InitializeCommonClipRectState(
     PropertyTreeState& source_property_tree_state,
     PropertyTreeState& destination_property_tree_state) const {
   DCHECK(use_geometry_mapper_);
-  DCHECK(layer_.GetLayoutObject().LocalBorderBoxProperties());
 
+  DCHECK(layer_.GetLayoutObject().LocalBorderBoxProperties());
   source_property_tree_state =
       *layer_.GetLayoutObject().LocalBorderBoxProperties();
+
   DCHECK(context.root_layer->GetLayoutObject().LocalBorderBoxProperties());
   destination_property_tree_state =
       *context.root_layer->GetLayoutObject().LocalBorderBoxProperties();
 
   auto* ancestor_properties =
       context.root_layer->GetLayoutObject().PaintProperties();
-  const auto* ancestor_css_clip =
-      ancestor_properties ? ancestor_properties->CssClip() : nullptr;
-  // CSS clip of the root is always applied.
-  if (ancestor_css_clip) {
-    DCHECK(destination_property_tree_state.Clip() ==
-           ancestor_properties->CssClip());
-    destination_property_tree_state.SetClip(ancestor_css_clip->Parent());
+  if (!ancestor_properties)
+    return;
+
+  if (context.ShouldRespectRootLayerClip()) {
+    const auto* ancestor_css_clip = ancestor_properties->CssClip();
+    if (ancestor_css_clip) {
+      DCHECK_EQ(destination_property_tree_state.Clip(),
+                ancestor_css_clip);
+      destination_property_tree_state.SetClip(ancestor_css_clip->Parent());
+    }
+  } else {
+    const auto* ancestor_overflow_clip = ancestor_properties->OverflowClip();
+    if (ancestor_overflow_clip) {
+      DCHECK_EQ(destination_property_tree_state.Clip(),
+                ancestor_overflow_clip->Parent());
+      destination_property_tree_state.SetClip(ancestor_overflow_clip);
+    }
   }
 }
 
@@ -572,29 +606,9 @@ void PaintLayerClipper::GetOrCalculateClipRects(const ClipRectsContext& context,
 
 bool PaintLayerClipper::ShouldClipOverflow(
     const ClipRectsContext& context) const {
-  if (!layer_.GetLayoutObject().IsBox())
-    return false;
-  const LayoutBox& box = ToLayoutBox(layer_.GetLayoutObject());
-
-  if (!ShouldRespectOverflowClip(context))
+  if (&layer_ == context.root_layer && !context.ShouldRespectRootLayerClip())
     return false;
-
-  return box.ShouldClipOverflow();
-}
-
-bool PaintLayerClipper::ShouldRespectOverflowClip(
-    const ClipRectsContext& context) const {
-  if (&layer_ != context.root_layer)
-    return true;
-
-  if (context.respect_overflow_clip == kIgnoreOverflowClip)
-    return false;
-
-  if (layer_.IsRootLayer() &&
-      context.respect_overflow_clip_for_viewport == kIgnoreOverflowClip)
-    return false;
-
-  return true;
+  return HasOverflowClip(layer_);
 }
 
 ClipRects& PaintLayerClipper::PaintingClipRects(

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

@@ -96,6 +96,8 @@ class ClipRectsContext {
 
   ClipRectsCacheSlot CacheSlot() const { return cache_slot_; }
 
+  bool ShouldRespectRootLayerClip() const;
+
   const PaintLayer* root_layer;
   const OverlayScrollbarClipBehavior overlay_scrollbar_clip_behavior;
 
@@ -220,7 +222,6 @@ class CORE_EXPORT PaintLayerClipper {
   void GetOrCalculateClipRects(const ClipRectsContext&, ClipRects&) const;
 
   ALWAYS_INLINE bool ShouldClipOverflow(const ClipRectsContext&) const;
-  ALWAYS_INLINE bool ShouldRespectOverflowClip(const ClipRectsContext&) const;
 
   // Returned clip rect in |output| is in the space of the context's rootLayer.
   ALWAYS_INLINE void CalculateBackgroundClipRectWithGeometryMapper(

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

@@ -512,4 +512,114 @@ TEST_P(PaintLayerClipperTest, Filter) {
   EXPECT_EQ(LayoutRect(0, 0, 100, 200), foreground_rect.Rect());
 }
 
+// Computed infinite clip rects may not match LayoutRect::InfiniteIntRect()
+// due to floating point errors.
+static bool IsInfinite(const LayoutRect& rect) {
+  return rect.X().Round() < -10000000 && rect.MaxX().Round() > 10000000
+      && rect.Y().Round() < -10000000 && rect.MaxY().Round() > 10000000;
+}
+
+TEST_P(PaintLayerClipperTest, IgnoreRootLayerClipWithCSSClip) {
+  SetBodyInnerHTML(
+      "<style>"
+      "  #root { "
+      "    width: 400px; height: 400px;"
+      "    position: absolute; clip: rect(0, 50px, 100px, 0);"
+      "  }"
+      "  #target {"
+      "    position: relative;"
+      "  }"
+      "</style>"
+      "<div id='root'>"
+      "  <div id='target'></div>"
+      "</div>");
+
+  PaintLayer* root =
+      ToLayoutBoxModelObject(GetLayoutObjectByElementId("root"))->Layer();
+  PaintLayer* target =
+      ToLayoutBoxModelObject(GetLayoutObjectByElementId("target"))->Layer();
+  ClipRectsContext context(root, kPaintingClipRectsIgnoringOverflowClip);
+  PaintLayer::GeometryMapperOption option = PaintLayer::kDoNotUseGeometryMapper;
+  if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
+    option = PaintLayer::kUseGeometryMapper;
+  LayoutRect infinite_rect(LayoutRect::InfiniteIntRect());
+  LayoutRect layer_bounds(infinite_rect);
+  ClipRect background_rect(infinite_rect);
+  ClipRect foreground_rect(infinite_rect);
+  target->Clipper(option).CalculateRects(context, infinite_rect, layer_bounds,
+                                         background_rect, foreground_rect);
+
+  EXPECT_TRUE(IsInfinite(background_rect.Rect()));
+  EXPECT_TRUE(IsInfinite(foreground_rect.Rect()));
+}
+
+TEST_P(PaintLayerClipperTest, IgnoreRootLayerClipWithOverflowClip) {
+  SetBodyInnerHTML(
+      "<style>"
+      "  #root { "
+      "    width: 400px; height: 400px;"
+      "    overflow: hidden;"
+      "  }"
+      "  #target {"
+      "    position: relative;"
+      "  }"
+      "</style>"
+      "<div id='root'>"
+      "  <div id='target'></div>"
+      "</div>");
+
+  PaintLayer* root =
+      ToLayoutBoxModelObject(GetLayoutObjectByElementId("root"))->Layer();
+  PaintLayer* target =
+      ToLayoutBoxModelObject(GetLayoutObjectByElementId("target"))->Layer();
+  ClipRectsContext context(root, kPaintingClipRectsIgnoringOverflowClip);
+  PaintLayer::GeometryMapperOption option = PaintLayer::kDoNotUseGeometryMapper;
+  if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
+    option = PaintLayer::kUseGeometryMapper;
+  LayoutRect infinite_rect(LayoutRect::InfiniteIntRect());
+  LayoutRect layer_bounds(infinite_rect);
+  ClipRect background_rect(infinite_rect);
+  ClipRect foreground_rect(infinite_rect);
+  target->Clipper(option).CalculateRects(context, infinite_rect, layer_bounds,
+                                         background_rect, foreground_rect);
+
+  EXPECT_TRUE(IsInfinite(background_rect.Rect()));
+  EXPECT_TRUE(IsInfinite(foreground_rect.Rect()));
+}
+
+TEST_P(PaintLayerClipperTest, IgnoreRootLayerClipWithBothClip) {
+  SetBodyInnerHTML(
+      "<style>"
+      "  #root { "
+      "    width: 400px; height: 400px;"
+      "    position: absolute; clip: rect(0, 50px, 100px, 0);"
+      "    overflow: hidden;"
+      "  }"
+      "  #target {"
+      "    position: relative;"
+      "  }"
+      "</style>"
+      "<div id='root'>"
+      "  <div id='target'></div>"
+      "</div>");
+
+  PaintLayer* root =
+      ToLayoutBoxModelObject(GetLayoutObjectByElementId("root"))->Layer();
+  PaintLayer* target =
+      ToLayoutBoxModelObject(GetLayoutObjectByElementId("target"))->Layer();
+  ClipRectsContext context(root, kPaintingClipRectsIgnoringOverflowClip);
+  PaintLayer::GeometryMapperOption option = PaintLayer::kDoNotUseGeometryMapper;
+  if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
+    option = PaintLayer::kUseGeometryMapper;
+  LayoutRect infinite_rect(LayoutRect::InfiniteIntRect());
+  LayoutRect layer_bounds(infinite_rect);
+  ClipRect background_rect(infinite_rect);
+  ClipRect foreground_rect(infinite_rect);
+  target->Clipper(option).CalculateRects(context, infinite_rect, layer_bounds,
+                                         background_rect, foreground_rect);
+
+  EXPECT_TRUE(IsInfinite(background_rect.Rect()));
+  EXPECT_TRUE(IsInfinite(foreground_rect.Rect()));
+}
+
 }  // namespace blink