Remove clips where we can show that they are unnecessary.

Source/core/rendering/RenderBlock.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 1696 matching lines @@
         if (!repaintRect.isEmpty()) {
             repaintRectangle(repaintRect); // We need to do a partial repaint of our content.
             if (hasReflection())
                 repaintRectangle(reflectedRect(repaintRect));
         }
     }
 
     setNeedsLayout(false);
 }
 
+void RenderBlock::addVisualOverflow(const LayoutRect& rect, VisualOverflowClipBehavior clipBehavior)
+{
+    if (clipBehavior == VisualOverflowClippedByContentsClip && hasOverflowClip() && m_rareData) {
+        m_rareData->m_contentsVisualOverflowRect.uniteIfNonZero(rect);

[Julien - ping for review, 2013/06/19 19:42:58]

Why isn't this in RenderOverflow as it is its reason to be?

[jbroman, 2013/08/02 14:28:17]

Moved as requested.

+        return;
+    }
+    RenderBox::addVisualOverflow(rect, clipBehavior);
+}
+
 void RenderBlock::addOverflowFromChildren()
 {
     if (!hasColumns()) {
         if (childrenInline())
             addOverflowFromInlineChildren();
         else
             addOverflowFromBlockChildren();
     } else {
         ColumnInfo* colInfo = columnInfo();
         if (columnCount(colInfo)) {
             LayoutRect lastRect = columnRectAt(colInfo, columnCount(colInfo) - 1);
             addLayoutOverflow(lastRect);
-            if (!hasOverflowClip())
-                addVisualOverflow(lastRect);
+            addVisualOverflow(lastRect, VisualOverflowClippedByContentsClip);
         }
     }
 }
 
 void RenderBlock::computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats)
 {
     m_overflow.clear();
+    if (hasOverflowClip()) {
+        if (!m_rareData)
+            m_rareData = adoptPtr(new RenderBlockRareData(this));
+        m_rareData->m_contentsVisualOverflowRect = LayoutRect();

[Julien - ping for review, 2013/06/19 19:42:58]

You are now forcing all RenderBlocks with an overflow clip to have a rare data
as computeOverflow is called for each layout. And that is regardless of whether
you will have a need for it.

[jbroman, 2013/08/02 14:28:17]

Changed to RenderOverflow. Note that in practice most elements with overflow
clips will have *some*  contents and will get a RenderOverflow to store their
contents visual bounding rect anyhow. This could be possibly avoided for
"overflow: hidden" but not for "overflow: scroll".

+    }
 
     // Add overflow from children.
     addOverflowFromChildren();
 
     if (!hasColumns() && (recomputeFloats || isRoot() || expandsToEncloseOverhangingFloats() || hasSelfPaintingLayer()))
         addOverflowFromFloats();
 
     // Add in the overflow from positioned objects.
     addOverflowFromPositionedObjects();
 
     if (hasOverflowClip()) {
         // When we have overflow clip, propagate the original spillout since it will include collapsed bottom margins
         // and bottom padding.  Set the axis we don't care about to be 1, since we want this overflow to always
         // be considered reachable.
         LayoutRect clientRect(clientBoxRect());
         LayoutRect rectToApply;
         if (isHorizontalWritingMode())
             rectToApply = LayoutRect(clientRect.x(), clientRect.y(), 1, max<LayoutUnit>(0, oldClientAfterEdge - clientRect.y()));
         else
             rectToApply = LayoutRect(clientRect.x(), clientRect.y(), max<LayoutUnit>(0, oldClientAfterEdge - clientRect.x()), 1);
         addLayoutOverflow(rectToApply);
         if (hasRenderOverflow())
             m_overflow->setLayoutClientAfterEdge(oldClientAfterEdge);
     }
-        
+
     // Allow our overflow to catch cases where the caret in an empty editable element with negative text indent needs to get painted.
     LayoutUnit textIndent = textIndentOffset();
     if (textIndent < 0) {
         LayoutRect clientRect(clientBoxRect());
-        LayoutRect rectToApply = LayoutRect(clientRect.x() + min<LayoutUnit>(0, textIndent), clientRect.y(), clientRect.width() - min<LayoutUnit>(0, textIndent), clientRect.height());

[Julien - ping for review, 2013/06/19 19:42:58]

Removing the min seems wrong: textIndent is negative in that branch.

[jbroman, 2013/08/02 14:28:17]

min returns the lesser of its arguments. If textIndent < 0, then the lesser of 0
and textIndent is necessarily 0, no?

That said, removing it from this CL to make the diff nicer.

[jbroman, 2013/08/02 15:02:20]

Err, I meant "is necessarily textIndent". The change was correct; my
sentence-forming abilities are questionable.

[Julien - ping for review, 2013/08/07 00:17:08]

Yeah, I misread the condition and your code was right. My bad!

-        addVisualOverflow(rectToApply);
+        LayoutRect rectToApply = LayoutRect(clientRect.x() + textIndent, clientRect.y(), clientRect.width() - textIndent, clientRect.height());
+        addVisualOverflow(rectToApply, VisualOverflowClippedByContentsClip);
     }
 
     // Add visual overflow from box-shadow and border-image-outset.
     addVisualEffectOverflow();
 
     // Add visual overflow from theme.
     addVisualOverflowFromTheme();
 
     if (isRenderFlowThread())
         toRenderFlowThread(this)->computeOverflowStateForRegions(oldClientAfterEdge);
@@ skipping 24 matching lines @@
 void RenderBlock::addOverflowFromPositionedObjects()
 {
     TrackedRendererListHashSet* positionedDescendants = positionedObjects();
     if (!positionedDescendants)
         return;
 
     RenderBox* positionedObject;
     TrackedRendererListHashSet::iterator end = positionedDescendants->end();
     for (TrackedRendererListHashSet::iterator it = positionedDescendants->begin(); it != end; ++it) {
         positionedObject = *it;
-        
-        // Fixed positioned elements don't contribute to layout overflow, since they don't scroll with the content.
-        if (positionedObject->style()->position() != FixedPosition) {

[Julien - ping for review, 2013/06/19 19:42:58]

I am not sure I see the point of this change: you are basically still ignoring
fixed positioned objects in addOverflowFromChild as you explicitly ignore them
for layout overflow and they have a self-painting layer. However to arrive at
the same result, you do a lot more computations.

[jbroman, 2013/08/02 14:28:17]

Good point. Reverted.

-            LayoutUnit x = positionedObject->x();
-            if (style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
-                x -= verticalScrollbarWidth();
-            addOverflowFromChild(positionedObject, LayoutSize(x, positionedObject->y()));
-        }
+        LayoutUnit x = positionedObject->x();
+        if (style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
+            x -= verticalScrollbarWidth();
+        addOverflowFromChild(positionedObject, LayoutSize(x, positionedObject->y()));
     }
 }
 
 void RenderBlock::addVisualOverflowFromTheme()
 {
     if (!style()->hasAppearance())
         return;
 
     IntRect inflatedRect = pixelSnappedBorderBoxRect();
     theme()->adjustRepaintRect(this, inflatedRect);
-    addVisualOverflow(inflatedRect);
+    addVisualOverflow(inflatedRect, VisualOverflowNotClipped);
 }
 
 bool RenderBlock::expandsToEncloseOverhangingFloats() const
 {
     return isInlineBlockOrInlineTable() || isFloatingOrOutOfFlowPositioned() || hasOverflowClip() || (parent() && parent()->isFlexibleBoxIncludingDeprecated())
            || hasColumns() || isTableCell() || isTableCaption() || isFieldset() || isWritingModeRoot() || isRoot();
 }
 
 void RenderBlock::adjustPositionedBlock(RenderBox* child, const MarginInfo& marginInfo)
 {
@@ skipping 1048 matching lines @@
         FloatingObject* r = *it;
         // Only repaint the object if it is overhanging, is not in its own layer, and
         // is our responsibility to paint (m_shouldPaint is set). When paintAllDescendants is true, the latter
         // condition is replaced with being a descendant of us.
         if (logicalBottomForFloat(r) > logicalHeight() && ((paintAllDescendants && r->m_renderer->isDescendantOf(this)) || r->shouldPaint()) && !r->m_renderer->hasSelfPaintingLayer()) {
             r->m_renderer->repaint();
             r->m_renderer->repaintOverhangingFloats(false);
         }
     }
 }
- 
+
+static bool hasCaret(RenderObject* o)
+{
+    Frame* frame = o->frame();
+    if (frame->selection()->caretRenderer() == o)
+        return frame->selection()->rendererIsEditable() || (frame->settings() && frame->settings()->caretBrowsingEnabled());
+    if (frame->page()->dragCaretController()->caretRenderer() == o)
+        return frame->page()->dragCaretController()->isContentEditable() || (frame->settings() && frame->settings()->caretBrowsingEnabled());
+    return false;
+}

[Julien - ping for review, 2013/06/19 19:42:58]

This should probably be shared with the logic in RenderBlock::paintCaret as they
are very similar.

[jbroman, 2013/08/02 14:28:17]

They diverged and then grew together again. Created RenderBlock::hasCaret to
deduplicate.

+
 void RenderBlock::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     ANNOTATE_GRAPHICS_CONTEXT(paintInfo, this);
 
     LayoutPoint adjustedPaintOffset = paintOffset + location();
-    
     PaintPhase phase = paintInfo.phase;
 
     // Check if we need to do anything at all.
     // FIXME: Could eliminate the isRoot() check if we fix background painting so that the RenderView
     // paints the root's background.
     if (!isRoot()) {
         LayoutRect overflowBox = overflowRectForPaintRejection();
         flipForWritingMode(overflowBox);
         overflowBox.inflate(maximalOutlineSize(paintInfo.phase));
         overflowBox.moveBy(adjustedPaintOffset);
         if (!overflowBox.intersects(paintInfo.rect))
             return;
     }
 
-    bool pushedClip = pushContentsClip(paintInfo, adjustedPaintOffset);
+    const LayoutRect* contentsVisualOverflowRect = 0;
+    if (m_rareData && !hasControlClip() && !hasCaret(this) && !(shouldPaintSelectionGaps() && phase == PaintPhaseForeground)) {
+        // Some visual elements clipped by the control clip are not included in m_contentsVisualOverflowRect.
+        // It is also somewhat complicated to determine whether the caret and selection gaps, if present, would be clipped.
+        // FIXME: Determine whether these would be clipped instead of indiscriminately bailing out.
+        contentsVisualOverflowRect = &m_rareData->m_contentsVisualOverflowRect;
+    }
+    bool pushedClip = pushContentsClip(paintInfo, adjustedPaintOffset, contentsVisualOverflowRect);
     paintObject(paintInfo, adjustedPaintOffset);
     if (pushedClip)
         popContentsClip(paintInfo, phase, adjustedPaintOffset);
 
     // Our scrollbar widgets paint exactly when we tell them to, so that they work properly with
     // z-index.  We paint after we painted the background/border, so that the scrollbars will
     // sit above the background/border.
     if (hasOverflowClip() && style()->visibility() == VISIBLE && (phase == PaintPhaseBlockBackground || phase == PaintPhaseChildBlockBackground) && paintInfo.shouldPaintWithinRoot(this) && !paintInfo.paintRootBackgroundOnly())
         layer()->paintOverflowControls(paintInfo.context, roundedIntPoint(adjustedPaintOffset), paintInfo.rect);
 }
@@ skipping 276 matching lines @@
                 cb->addContinuationWithOutline(inlineRenderer);
             else if (!inlineRenderer->firstLineBox() || (!inlineEnclosedInSelfPaintingLayer && hasLayer()))
                 inlineRenderer->paintOutline(paintInfo, paintOffset - locationOffset() + inlineRenderer->containingBlock()->location());
         }
         paintContinuationOutlines(paintInfo, paintOffset);
     }
 
     // 7. paint caret.
     // If the caret's node's render object's containing block is this block, and the paint action is PaintPhaseForeground,
     // then paint the caret.
-    if (paintPhase == PaintPhaseForeground) {        
+    if (paintPhase == PaintPhaseForeground) {
         paintCaret(paintInfo, paintOffset, CursorCaret);
         paintCaret(paintInfo, paintOffset, DragCaret);
     }
 }
 
 LayoutPoint RenderBlock::flipFloatForWritingModeForChild(const FloatingObject* child, const LayoutPoint& point) const
 {
     if (!style()->isFlippedBlocksWritingMode())
         return point;
     
@@ skipping 4883 matching lines @@
 {
     memoryInstrumentation->addRootObject(gColumnInfoMap, WebCoreMemoryTypes::RenderingStructures);
     memoryInstrumentation->addRootObject(gPositionedDescendantsMap, WebCoreMemoryTypes::RenderingStructures);
     memoryInstrumentation->addRootObject(gPercentHeightDescendantsMap, WebCoreMemoryTypes::RenderingStructures);
     memoryInstrumentation->addRootObject(gPositionedContainerMap, WebCoreMemoryTypes::RenderingStructures);
     memoryInstrumentation->addRootObject(gPercentHeightContainerMap, WebCoreMemoryTypes::RenderingStructures);
     memoryInstrumentation->addRootObject(gDelayedUpdateScrollInfoSet, WebCoreMemoryTypes::RenderingStructures);
 }
 
 } // namespace WebCore