IntersectionObserver: make exceptions match spec

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 10 matching lines @@
     , m_shouldReportRootBounds(shouldReportRootBounds)
     , m_lastThresholdIndex(0)
 {
 }
 
 Element* IntersectionObservation::target() const
 {
     return toElement(m_target.get());
 }
 
-void IntersectionObservation::initializeGeometry(IntersectionGeometry& geometry)
+void IntersectionObservation::applyRootMargin(LayoutRect& rect) const
+{
+    if (m_shouldReportRootBounds)
+        m_observer->applyRootMargin(rect);
+}
+
+void IntersectionObservation::initializeGeometry(IntersectionGeometry& geometry) const
 {
     ASSERT(m_target);
     LayoutObject* targetLayoutObject = target()->layoutObject();
     if (targetLayoutObject->isBoxModelObject())
         geometry.targetRect = toLayoutBoxModelObject(targetLayoutObject)->visualOverflowRect();
     else
         geometry.targetRect = toLayoutText(targetLayoutObject)->visualOverflowRect();
     if (!geometry.targetRect.size().width())
         geometry.targetRect.setWidth(LayoutUnit(1));
     if (!geometry.targetRect.size().height())
         geometry.targetRect.setHeight(LayoutUnit(1));
     geometry.intersectionRect = geometry.targetRect;
 }
 
-void IntersectionObservation::clipToRoot(LayoutRect& rect)
+void IntersectionObservation::clipToRoot(LayoutRect& rect) 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);
     if (rootLayoutObject->hasOverflowClip()) {
         LayoutBox* rootLayoutBox = toLayoutBox(rootLayoutObject);
         LayoutRect clipRect(LayoutPoint(), LayoutSize(rootLayoutBox->layer()->size()));
-        m_observer->applyRootMargin(clipRect);
+        applyRootMargin(clipRect);
         rootLayoutBox->flipForWritingMode(rect);
         rect.intersect(clipRect);
         rootLayoutBox->flipForWritingMode(rect);
     }
 }
 
-void IntersectionObservation::clipToFrameView(IntersectionGeometry& geometry)
+void IntersectionObservation::clipToFrameView(IntersectionGeometry& geometry) const
 {
     Node* rootNode = m_observer->rootNode();
     LayoutObject* rootLayoutObject = m_observer->rootLayoutObject();
     if (rootLayoutObject->isLayoutView()) {
         geometry.rootRect = LayoutRect(toLayoutView(rootLayoutObject)->frameView()->visibleContentRect());
-        m_observer->applyRootMargin(geometry.rootRect);
+        applyRootMargin(geometry.rootRect);
         geometry.intersectionRect.intersect(geometry.rootRect);
     } else {
         if (rootLayoutObject->isBox())
             geometry.rootRect = LayoutRect(toLayoutBox(rootLayoutObject)->absoluteContentBox());
         else
             geometry.rootRect = LayoutRect(rootLayoutObject->absoluteBoundingBoxRect());
-        m_observer->applyRootMargin(geometry.rootRect);
+        applyRootMargin(geometry.rootRect);
     }
 
     LayoutPoint scrollPosition(rootNode->document().view()->scrollPosition());
     geometry.targetRect.moveBy(-scrollPosition);
     geometry.intersectionRect.moveBy(-scrollPosition);
     geometry.rootRect.moveBy(-scrollPosition);
 }
 
 static void mapRectToDocumentCoordinates(LayoutObject& layoutObject, LayoutRect& rect)
 {
     rect = LayoutRect(layoutObject.localToAbsoluteQuad(FloatQuad(FloatRect(rect)), UseTransforms | ApplyContainerFlip | TraverseDocumentBoundaries).boundingBox());
 }
 
 static bool isContainingBlockChainDescendant(LayoutObject* descendant, LayoutObject* ancestor)
 {
     LocalFrame* ancestorFrame = ancestor->document().frame();
     LocalFrame* descendantFrame = descendant->document().frame();
 
     if (ancestor->isLayoutView())
         return descendantFrame && descendantFrame->tree().top() == ancestorFrame;
 
     if (ancestorFrame != descendantFrame)
         return false;
 
     while (descendant && descendant != ancestor)
         descendant = descendant->containingBlock();
     return descendant;
 }
 
-bool IntersectionObservation::computeGeometry(IntersectionGeometry& geometry)
+bool IntersectionObservation::computeGeometry(IntersectionGeometry& geometry) const
 {
     // Pre-oilpan, there will be a delay between the time when the target Element gets deleted
     // (because its ref count dropped to zero) and when this IntersectionObservation gets
     // deleted (during the next gc run, because the target Element is the only thing keeping
     // the IntersectionObservation alive).  During that interval, we need to check that m_target
     // hasn't been cleared.
     Element* targetElement = target();
     if (!targetElement || !targetElement->inDocument())
         return false;
     LayoutObject* targetLayoutObject = targetElement->layoutObject();
@@ skipping 75 matching lines @@
     m_observer.clear();
 }
 
 DEFINE_TRACE(IntersectionObservation)
 {
     visitor->trace(m_observer);
     visitor->trace(m_target);
 }
 
 } // namespace blink