IntersectionObserver: use edge-inclusive geometry for intersections.

third_party/WebKit/Source/core/dom/IntersectionObservation.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/dom/IntersectionObservation.h"
 
 #include "core/dom/ElementRareData.h"
 #include "core/dom/IntersectionObserver.h"
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutBox.h"
@@ skipping 16 matching lines @@
 {
     return toElement(m_target.get());
 }
 
 void IntersectionObservation::applyRootMargin(LayoutRect& rect) const
 {
     if (m_shouldReportRootBounds)
         m_observer->applyRootMargin(rect);
 }
 
+void IntersectionObservation::initializeGeometry(IntersectionGeometry& geometry) const
+{
+    initializeTargetRect(geometry.targetRect);
+    geometry.intersectionRect = geometry.targetRect;
+    initializeRootRect(geometry.rootRect);
+    geometry.doesIntersect = true;
+}
+
 void IntersectionObservation::initializeTargetRect(LayoutRect& rect) const
 {
     ASSERT(m_target);
     LayoutObject* targetLayoutObject = target()->layoutObject();
     ASSERT(targetLayoutObject && targetLayoutObject->isBoxModelObject());
     rect = toLayoutBoxModelObject(targetLayoutObject)->visualOverflowRect();
-
-    // TODO(szager): Properly support intersection observations for zero-area targets
-    //   by using edge-inclusive geometry.
-    if (!rect.size().width())
-        rect.setWidth(LayoutUnit(1));
-    if (!rect.size().height())
-        rect.setHeight(LayoutUnit(1));
 }
 
 void IntersectionObservation::initializeRootRect(LayoutRect& rect) const
 {
     LayoutObject* rootLayoutObject = m_observer->rootLayoutObject();
     if (rootLayoutObject->isLayoutView())
         rect = LayoutRect(toLayoutView(rootLayoutObject)->frameView()->visibleContentRect());
     // TODO(szager): Obey the spec -- use content box for a scrolling element, border box otherwise.
     else if (rootLayoutObject->isBox())
         rect = LayoutRect(toLayoutBox(rootLayoutObject)->contentBoxRect());
     else
         rect = LayoutRect(toLayoutBoxModelObject(rootLayoutObject)->borderBoundingBox());
     applyRootMargin(rect);
 }
 
-void IntersectionObservation::clipToRoot(LayoutRect& rect, const LayoutRect& rootRect) const
+void IntersectionObservation::clipToRoot(IntersectionGeometry& geometry) const
 {
     // Map and clip rect into root element coordinates.
     // TODO(szager): the writing mode flipping needs a test.
     ASSERT(m_target);
     LayoutObject* rootLayoutObject = m_observer->rootLayoutObject();
     LayoutObject* targetLayoutObject = target()->layoutObject();
 
-    targetLayoutObject->mapToVisibleRectInAncestorSpace(toLayoutBoxModelObject(rootLayoutObject), rect, nullptr);
-    LayoutRect rootClipRect(rootRect);
+    geometry.doesIntersect = targetLayoutObject->mapToVisibleRectInAncestorSpace(toLayoutBoxModelObject(rootLayoutObject), geometry.intersectionRect, nullptr, EdgeInclusive);
+    if (!geometry.doesIntersect)
+        return;
+    LayoutRect rootClipRect(geometry.rootRect);
     toLayoutBox(rootLayoutObject)->flipForWritingMode(rootClipRect);
-    rect.intersect(rootClipRect);
+    geometry.doesIntersect &= geometry.intersectionRect.inclusiveIntersect(rootClipRect);
 }
 
 static void mapRectUpToDocument(LayoutRect& rect, const LayoutObject& layoutObject, const Document& document)
 {
     FloatQuad mappedQuad = layoutObject.localToAbsoluteQuad(
         FloatQuad(FloatRect(rect)),
         UseTransforms | ApplyContainerFlip);
     rect = LayoutRect(mappedQuad.boundingBox());
 }
 
@@ skipping 70 matching lines @@
     // TODO(szager): Support SVG
     if (!targetLayoutObject)
         return false;
     if (!targetLayoutObject->isBoxModelObject() && !targetLayoutObject->isText())
         return false;
     if (!rootLayoutObject || !rootLayoutObject->isBoxModelObject())
         return false;
     if (!isContainingBlockChainDescendant(targetLayoutObject, rootLayoutObject))
         return false;
 
-    initializeTargetRect(geometry.targetRect);
-    geometry.intersectionRect = geometry.targetRect;
-    initializeRootRect(geometry.rootRect);
+    initializeGeometry(geometry);
 
-    clipToRoot(geometry.intersectionRect, geometry.rootRect);
+    clipToRoot(geometry);
 
-    // TODO(szager): there are some simple optimizations that can be done here:
-    //   - Don't transform rootRect if it's not going to be reported
-    //   - Don't transform intersectionRect if it's empty
     mapTargetRectToTargetFrameCoordinates(geometry.targetRect);
-    mapRootRectToTargetFrameCoordinates(geometry.intersectionRect);
-    mapRootRectToRootFrameCoordinates(geometry.rootRect);
 
-    if (geometry.intersectionRect.size().isZero())
+    if (geometry.doesIntersect)
+        mapRootRectToTargetFrameCoordinates(geometry.intersectionRect);
+    else
         geometry.intersectionRect = LayoutRect();
 
+    // Small optimization: if we're not going to report root bounds, don't bother
+    // transforming them to the frame.
+    if (m_shouldReportRootBounds)
+        mapRootRectToRootFrameCoordinates(geometry.rootRect);
+
     return true;
 }
 
+enum IntersectionState {
+    NotIntersecting = 0,
+    Intersecting = 1
+};
+
 void IntersectionObservation::computeIntersectionObservations(DOMHighResTimeStamp timestamp)
 {
     IntersectionGeometry geometry;
     if (!computeGeometry(geometry))
         return;
 
-    float intersectionArea = geometry.intersectionRect.size().width().toFloat() * geometry.intersectionRect.size().height().toFloat();
-    float targetArea = geometry.targetRect.size().width().toFloat() * geometry.targetRect.size().height().toFloat();
-    if (!targetArea)
-        return;
-    float newVisibleRatio = intersectionArea / targetArea;
-    unsigned newThresholdIndex = observer().firstThresholdGreaterThan(newVisibleRatio);
-    IntRect snappedRootBounds = pixelSnappedIntRect(geometry.rootRect);
-    IntRect* rootBoundsPointer = m_shouldReportRootBounds ? &snappedRootBounds : nullptr;
+    // Some corner cases for threshold index:
+    //   - If target rect is zero area, because it has zero width and/or zero height,
+    //     only two states are recognized:
+    //     - 0 means not intersecting.
+    //     - 1 means intersecting.
+    //     No other threshold crossings are possible.
+    //   - Otherwise:
+    //     - If root and target do not intersect, the threshold index is 0.
+    //     - If root and target intersect but the intersection has zero-area (i.e., they
+    //       have a coincident edge or corner), we consider the intersection to have
+    //       "crossed" a zero threshold, but not crossed any non-zero threshold.
+    unsigned newThresholdIndex;
+    if (!geometry.doesIntersect) {
+        newThresholdIndex = NotIntersecting;
+    } else if (geometry.targetRect.isEmpty()) {
+        newThresholdIndex = Intersecting;
+    } else {
+        float intersectionArea = geometry.intersectionRect.size().width().toFloat() * geometry.intersectionRect.size().height().toFloat();
+        float targetArea = geometry.targetRect.size().width().toFloat() * geometry.targetRect.size().height().toFloat();
+        float newVisibleRatio = intersectionArea / targetArea;
+        newThresholdIndex = observer().firstThresholdGreaterThan(newVisibleRatio);

[chrishtr, 2016/03/25 14:54:47]

Oh I see. It is weird to have an enum combined with an index. You can revert the
enum change if you like.


Aren't there two interpretations of 0 and 1 in this implementation? AIUI 0 can
mean not intersecting, or less than all of the thresholds. 1 means intersecting
but zero-area, or larger than the 0th threshold but less than the 1st. Isn't
that a problem?

[szager1, 2016/03/25 17:03:10]

I think it's important to keep in mind that the purpose of this code is
correctly identify threshold crossings; newThresholdIndex is a
mostly-but-not-completely accurate variable name.  There are a couple of
threshold crossings that require special handling:

- The zero threshold has special meaning in the spec: it is crossed whenever
target and root transition from not intersecting to intersecting in any way
(including coincident edge intersections).

- If the target rect has zero area, then only two states are recognized:
intersecting (threshold index 0) and not intersecting (threshold index 1).

So yes, you are correct that a threshold index of 0 can mean two different
things: not intersecting at all, or intersecting but newVisibleRatio is smaller
than the first threshold (which consequently must not be a zero threshold).

+    }
     if (m_lastThresholdIndex != newThresholdIndex) {
+        IntRect snappedRootBounds = pixelSnappedIntRect(geometry.rootRect);
+        IntRect* rootBoundsPointer = m_shouldReportRootBounds ? &snappedRootBounds : nullptr;
         IntersectionObserverEntry* newEntry = new IntersectionObserverEntry(
             timestamp,
             pixelSnappedIntRect(geometry.targetRect),
             rootBoundsPointer,
             pixelSnappedIntRect(geometry.intersectionRect),
             target());
         observer().enqueueIntersectionObserverEntry(*newEntry);
     }
     setLastThresholdIndex(newThresholdIndex);
 }
@@ skipping 12 matching lines @@
     m_observer.clear();
 }
 
 DEFINE_TRACE(IntersectionObservation)
 {
     visitor->trace(m_observer);
     visitor->trace(m_target);
 }
 
 } // namespace blink