[blink] Unify PaintLayerClipper behavior with kIgnoreOverflowClip

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 35 matching lines @@
 
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/graphics/paint/GeometryMapper.h"
 
 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) {
   EPosition position = layout_object.StyleRef().GetPosition();
   // A fixed object is essentially the root of its containing block hierarchy,
   // so when we encounter such an object, we reset our clip rects to the
   // fixedClipRect.
   if (position == EPosition::kFixed) {
     clip_rects.SetPosClipRect(clip_rects.FixedClipRect());
     clip_rects.SetOverflowClipRect(clip_rects.FixedClipRect());
@@ skipping 313 matching lines @@
   const LayoutBoxModelObject& layout_object = layer_.GetLayoutObject();
   if (!layer_.Parent() &&
       !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     // The root layer's clip rect is always infinite.
     clip_rects.Reset(LayoutRect(LayoutRect::InfiniteIntRect()));
     return;
   }
 
   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.
   PaintLayer* parent_layer = !is_clipping_root ? layer_.Parent() : nullptr;
   // Ensure that our parent's clip has been calculated so that we can examine
   // the values.
   if (parent_layer) {
     PaintLayerClipper(*parent_layer, use_geometry_mapper_)
         .GetOrCalculateClipRects(context, clip_rects);
   } else {
     clip_rects.Reset(LayoutRect(LayoutRect::InfiniteIntRect()));
   }
 
   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
     // space.
     ApplyClipRects(context, layout_object,
                    LayoutPoint(layout_object.LocalToAncestorPoint(
                        FloatPoint(), &context.root_layer->GetLayoutObject())),
                    clip_rects);
   }
 }
 
 static ClipRect BackgroundClipRectForPosition(const ClipRects& parent_rects,
                                               EPosition position) {
   if (position == EPosition::kFixed)
     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 {
   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
   // 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 (HasOverflowClip(layer_)) {
     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);
   }
 
   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_);
+
   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);
+    }
   }
 }
 
 LayoutRect PaintLayerClipper::LocalVisualRect() const {
   const LayoutObject& layout_object = layer_.GetLayoutObject();
   // The LayoutView is special since its overflow clipping rect may be larger
   // than its box rect (crbug.com/492871).
   LayoutRect layer_bounds_with_visual_overflow =
       layout_object.IsLayoutView()
           ? ToLayoutView(layout_object).ViewRect()
@@ skipping 57 matching lines @@
   DCHECK(!use_geometry_mapper_);
 
   if (context.UsesCache())
     clip_rects = GetClipRects(context);
   else
     CalculateClipRects(context, clip_rects);
 }
 
 bool PaintLayerClipper::ShouldClipOverflow(
     const ClipRectsContext& context) const {
-  if (!layer_.GetLayoutObject().IsBox())
+  if (&layer_ == context.root_layer && !context.ShouldRespectRootLayerClip())
     return false;
-  const LayoutBox& box = ToLayoutBox(layer_.GetLayoutObject());
-
-  if (!ShouldRespectOverflowClip(context))
-    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(
     const PaintLayer* root_layer,
     ShouldRespectOverflowClipType respect_overflow_clip,
     const LayoutSize& subpixel_accumulation) const {
   DCHECK(!use_geometry_mapper_);
   ClipRectsContext context(root_layer, kPaintingClipRects,
                            kIgnorePlatformOverlayScrollbarSize,
                            subpixel_accumulation);
   if (respect_overflow_clip == kIgnoreOverflowClip)
     context.SetIgnoreOverflowClip();
   return GetClipRects(context);
 }
 
 }  // namespace blink