Support edge-inclusive intersections in mapToVisibleRectInAncestorSpace

third_party/WebKit/Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. 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
@@ skipping 955 matching lines @@
     LayoutSize offset = LayoutSize(-scrolledContentOffset());
     if (UNLIKELY(hasFlippedBlocksWritingMode())) {
         if (isHorizontalWritingMode())
             offset.setHeight(-offset.height());
         else
             offset.setWidth(-offset.width());
     }
     rect.move(offset);
 }
 
-void LayoutBox::applyOverflowClip(LayoutRect& rect) const
+bool LayoutBox::applyOverflowClip(LayoutRect& rect, bool edgeInclusive) const
 {
     ASSERT(hasLayer());
     ASSERT(hasOverflowClip());
 
     flipForWritingMode(rect);
 
     // size() is inaccurate if we're in the middle of a layout of this LayoutBox, so use the
     // layer's size instead. Even if the layer's size is wrong, the layer itself will issue paint invalidations
     // anyway if its size does change.
     LayoutRect clipRect(LayoutPoint(), LayoutSize(layer()->size()));
-    rect = intersection(rect, clipRect);
-    flipForWritingMode(rect);
+    bool doesIntersect;
+    if (edgeInclusive) {
+        doesIntersect = rect.inclusiveIntersect(clipRect);
+    } else {
+        rect.intersect(clipRect);
+        doesIntersect = !rect.isEmpty();

[eae, 2016/03/22 00:13:50]

LayoutRect::intersects will only ever return true for an empty rect if the other
rect is also empty.

Is an intersection between two empty rects really a use-case we need to care
about? I understand supporting zero sized rects to track things like scroll
position but when would the other rect ever be zero sized?

[szager1, 2016/03/22 00:55:48]

That's not true:

bool LayoutRect::intersects(const LayoutRect& other) const                      
                                                           
{                                                                               
                                                           
    // Checking emptiness handles negative widths as well as zero.              
                                                           
    return !isEmpty() && !other.isEmpty()                                       
                                                           
        && x() < other.maxX() && other.x() < maxX()                             
                                                           
        && y() < other.maxY() && other.y() < maxY();                            
                                                           
} 

If either rect is empty, then intersects() returns false.

[eae, 2016/03/22 17:54:15]

Oh, my bad. You're right. Never mind!

+    }
+    if (doesIntersect)
+        flipForWritingMode(rect);
+    return doesIntersect;
 }
 
 void LayoutBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
     minLogicalWidth = minPreferredLogicalWidth() - borderAndPaddingLogicalWidth();
     maxLogicalWidth = maxPreferredLogicalWidth() - borderAndPaddingLogicalWidth();
 }
 
 LayoutUnit LayoutBox::minPreferredLogicalWidth() const
 {
@@ skipping 468 matching lines @@
     }
     return false;
 }
 
 bool LayoutBox::intersectsVisibleViewport()
 {
     LayoutRect rect = visualOverflowRect();
     LayoutView* layoutView = view();
     while (layoutView->frame()->ownerLayoutObject())
         layoutView = layoutView->frame()->ownerLayoutObject()->view();
-    mapToVisibleRectInAncestorSpace(layoutView, rect, nullptr);
+    mapToVisibleRectInAncestorSpace(layoutView, rect, nullptr, false);
     return rect.intersects(LayoutRect(layoutView->frameView()->getScrollableArea()->visibleContentRectDouble()));
 }
 
 PaintInvalidationReason LayoutBox::invalidatePaintIfNeeded(const PaintInvalidationState& paintInvalidationState)
 {
     if (isFloating())
         paintInvalidationState.enclosingSelfPaintingLayer(*this).setNeedsPaintPhaseFloat();
 
     if (hasBoxDecorationBackground()
         // We also paint overflow controls in background phase.
@@ skipping 430 matching lines @@
 LayoutRect LayoutBox::clippedOverflowRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
     if (style()->visibility() != VISIBLE) {
         PaintLayer* layer = enclosingLayer();
         layer->updateDescendantDependentFlags();
         if (layer->subtreeIsInvisible())
             return LayoutRect();
     }
 
     LayoutRect r = visualOverflowRect();
-    mapToVisibleRectInAncestorSpace(paintInvalidationContainer, r, paintInvalidationState);
+    mapToVisibleRectInAncestorSpace(paintInvalidationContainer, r, paintInvalidationState, false);
     return r;
 }
 
-void LayoutBox::mapToVisibleRectInAncestorSpace(const LayoutBoxModelObject* ancestor, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState) const
+bool LayoutBox::mapToVisibleRectInAncestorSpace(const LayoutBoxModelObject* ancestor, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState, bool edgeInclusive) const
 {
     // The rect we compute at each step is shifted by our x/y offset in the parent container's coordinate space.
     // Only when we cross a writing mode boundary will we have to possibly flipForWritingMode (to convert into a more appropriate
     // offset corner for the enclosing container). This allows for a fully RL or BT document to issue paint invalidations
     // properly even during layout, since the rect remains flipped all the way until the end.
     //
     // LayoutView::computeRectForPaintInvalidation then converts the rect to physical coordinates. We also convert to
     // physical when we hit a paintInvalidationContainer boundary. Therefore the final rect returned is always in the
     // physical coordinate space of the paintInvalidationContainer.
     const ComputedStyle& styleToUse = styleRef();
 
     EPosition position = styleToUse.position();
 
     // We need to inflate the paint invalidation rect before we use paintInvalidationState,
     // else we would forget to inflate it for the current layoutObject. FIXME: If these were
     // included into the visual overflow for repaint, we wouldn't have this issue.
     inflatePaintInvalidationRectForReflectionAndFilter(rect);
 
     if (paintInvalidationState && paintInvalidationState->canMapToAncestor(ancestor) && position != FixedPosition) {
-        paintInvalidationState->mapObjectRectToAncestor(*this, ancestor, rect);
-        return;
+        return paintInvalidationState->mapObjectRectToAncestor(*this, ancestor, rect, edgeInclusive);
     }
 
     if (ancestor == this) {
         if (ancestor->style()->isFlippedBlocksWritingMode())
             flipForWritingMode(rect);
-        return;
+        return true;
     }
 
     bool containerSkipped;
     LayoutObject* container = this->container(ancestor, &containerSkipped);
     if (!container)
-        return;
+        return true;
 
     if (isWritingModeRoot())
         flipForWritingMode(rect);
 
     LayoutPoint topLeft = rect.location();
     topLeft.move(locationOffset());
 
     // We are now in our parent container's coordinate space.  Apply our transform to obtain a bounding box
     // in the parent's coordinate space that encloses us.
     if (hasLayer() && layer()->transform()) {
@@ skipping 11 matching lines @@
         // flag on the LayoutObject has been cleared, so use the one on the style().
         topLeft += layer()->offsetForInFlowPosition();
     }
 
     // FIXME: We ignore the lightweight clipping rect that controls use, since if |o| is in mid-layout,
     // its controlClipRect will be wrong. For overflow clip we use the values cached by the layer.
     rect.setLocation(topLeft);
     if (container->hasOverflowClip()) {
         LayoutBox* containerBox = toLayoutBox(container);
         containerBox->mapScrollingContentsRectToBoxSpace(rect);
-        if (container != ancestor)
-            containerBox->applyOverflowClip(rect);
-        if (rect.isEmpty())
-            return;
+        if (container != ancestor && !containerBox->applyOverflowClip(rect, edgeInclusive))
+            return false;
     }
 
     if (containerSkipped) {
         // If the paintInvalidationContainer is below o, then we need to map the rect into paintInvalidationContainer's coordinates.
         LayoutSize containerOffset = ancestor->offsetFromAncestorContainer(container);
         rect.move(-containerOffset);
         // If the paintInvalidationContainer is fixed, then the rect is already in its coordinates so doesn't need viewport-adjusting.
         if (ancestor->style()->position() != FixedPosition && container->isLayoutView())
             toLayoutView(container)->adjustViewportConstrainedOffset(rect, LayoutView::toViewportConstrainedPosition(position));
-        return;
+        return true;
     }
 
     if (container->isLayoutView())
-        toLayoutView(container)->mapToVisibleRectInAncestorSpace(ancestor, rect, LayoutView::toViewportConstrainedPosition(position), paintInvalidationState);
+        return toLayoutView(container)->mapToVisibleRectInAncestorSpace(ancestor, rect, LayoutView::toViewportConstrainedPosition(position), paintInvalidationState, edgeInclusive);
     else
-        container->mapToVisibleRectInAncestorSpace(ancestor, rect, paintInvalidationState);
+        return container->mapToVisibleRectInAncestorSpace(ancestor, rect, paintInvalidationState, edgeInclusive);
 }
 
 void LayoutBox::inflatePaintInvalidationRectForReflectionAndFilter(LayoutRect& paintInvalidationRect) const
 {
     if (hasReflection())
         paintInvalidationRect.unite(reflectedRect(paintInvalidationRect));
 
     if (layer() && layer()->hasFilter())
         paintInvalidationRect.expand(layer()->filterOutsets());
 }
@@ skipping 2677 matching lines @@
 
 void LayoutBox::clearPercentHeightDescendants()
 {
     for (LayoutObject* curr = slowFirstChild(); curr; curr = curr->nextInPreOrder(this)) {
         if (curr->isBox())
             toLayoutBox(curr)->removeFromPercentHeightContainer();
     }
 }
 
 } // namespace blink