Expand PaintLayer clip to account for hidden URL bar with document.rootScroller

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 312 matching lines @@
     ClipRect& backgroundRect,
     ClipRect& foregroundRect,
     const LayoutPoint* offsetFromRoot) const {
   if (m_geometryMapper) {
     calculateRectsWithGeometryMapper(context, paintDirtyRect, layerBounds,
                                      backgroundRect, foregroundRect,
                                      offsetFromRoot);
     return;
   }
 
-  bool isClippingRoot = &m_layer == context.rootLayer;
   LayoutBoxModelObject& layoutObject = *m_layer.layoutObject();
 
-  if (!isClippingRoot && m_layer.parent()) {
+  if (!isClippingRoot(context) && m_layer.parent()) {
     backgroundRect = backgroundClipRect(context);
     backgroundRect.move(context.subPixelAccumulation);
     backgroundRect.intersect(paintDirtyRect);
   } else {
     backgroundRect = paintDirtyRect;
   }
 
   foregroundRect = backgroundRect;
 
   LayoutPoint offset;
   if (offsetFromRoot)
     offset = *offsetFromRoot;
   else
     m_layer.convertToLayerCoords(context.rootLayer, offset);
   layerBounds = LayoutRect(offset, LayoutSize(m_layer.size()));
 
   // Update the clip rects that will be passed to child layers.
   if (shouldClipOverflow(context)) {
     foregroundRect.intersect(
         toLayoutBox(layoutObject)
             .overflowClipRect(offset, context.overlayScrollbarClipBehavior));
     if (layoutObject.styleRef().hasBorderRadius())
       foregroundRect.setHasRadius(true);
 
     // FIXME: Does not do the right thing with columns yet, since we don't yet
     // factor in the individual column boxes as overflow.
 
-    // The LayoutView is special since its overflow clipping rect may be larger
-    // than its box rect (crbug.com/492871).
+    // The RootScroller (typically LayoutView) is special since its overflow
+    // clipping rect may be larger than its box rect (crbug.com/492871).
+    DCHECK(!m_layer.isRootScrollerLayer() ||
+           layoutObject.document().topDocument().layoutView());
     LayoutRect layerBoundsWithVisualOverflow =
-        layoutObject.isLayoutView()
-            ? toLayoutView(layoutObject).viewRect()
+        m_layer.isRootScrollerLayer()
+            ? layoutObject.document().topDocument().layoutView()->viewRect()
             : toLayoutBox(layoutObject).visualOverflowRect();
     // PaintLayer are in physical coordinates, so the overflow has to be
     // flipped.
     toLayoutBox(layoutObject).flipForWritingMode(layerBoundsWithVisualOverflow);
     layerBoundsWithVisualOverflow.moveBy(offset);
     backgroundRect.intersect(layerBoundsWithVisualOverflow);
   }
 
   // CSS clip (different than clipping due to overflow) can clip to any box,
   // even if it falls outside of the border box.
@@ skipping 10 matching lines @@
 void PaintLayerClipper::calculateClipRects(const ClipRectsContext& context,
                                            ClipRects& clipRects) const {
   const LayoutBoxModelObject& layoutObject = *m_layer.layoutObject();
   if (!m_layer.parent() &&
       !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     // The root layer's clip rect is always infinite.
     clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
     return;
   }
 
-  bool isClippingRoot = &m_layer == context.rootLayer;
-
   // 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* parentLayer = !isClippingRoot ? m_layer.parent() : nullptr;
+  PaintLayer* parentLayer =
+      !isClippingRoot(context) ? m_layer.parent() : nullptr;
   // Ensure that our parent's clip has been calculated so that we can examine
   // the values.
   if (parentLayer) {
     parentLayer->clipper().getOrCalculateClipRects(context, clipRects);
   } else {
     clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
   }
 
   adjustClipRectsForChildren(layoutObject, clipRects);
 
@@ skipping 77 matching lines @@
             // PaintLayer are in physical coordinates, so the overflow has to be
             // flipped.
             layerBoundsWithVisualOverflow);
     mapLocalToRootWithGeometryMapper(context, layerBoundsWithVisualOverflow);
     clipRect.intersect(FloatRect(layerBoundsWithVisualOverflow));
   }
 
   return ClipRect(LayoutRect(clipRect));
 }
 
+bool PaintLayerClipper::isClippingRoot(const ClipRectsContext& context) const {
+  return &m_layer == context.rootLayer || m_layer.isRootScrollerLayer();
+}
+
 ClipRect PaintLayerClipper::backgroundClipRect(
     const ClipRectsContext& context) const {
   if (m_geometryMapper) {
     ClipRect backgroundClipRect = clipRectWithGeometryMapper(context, false);
 #ifdef CHECK_CLIP_RECTS
     ClipRect testBackgroundClipRect =
         PaintLayerClipper(m_layer, false).backgroundClipRect(context);
     CHECK_RECTS_EQ(testBackgroundClipRect, backgroundClipRect);
 #endif
     return backgroundClipRect;
@@ skipping 61 matching lines @@
     const LayoutSize& subpixelAccumulation) const {
   DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnoreOverlayScrollbarSize, subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink