Use Document, rather than document element, for implicit root.

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"
 #include "core/layout/LayoutText.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/PaintLayer.h"
 
 namespace blink {
 
 IntersectionObservation::IntersectionObservation(IntersectionObserver& observer, Element& target, bool shouldReportRootBounds)
     : m_observer(observer)
     , m_target(target.ensureIntersectionObserverData().createWeakPtr(&target))
     , m_active(true)
     , m_shouldReportRootBounds(shouldReportRootBounds)
     , m_lastThresholdIndex(0)
 {
 }
 
+Element* IntersectionObservation::target() const
+{
+    return toElement(m_target.get());

[ojan, 2016/01/12 01:28:18]

How do you know this is an Element and not the Document?

Nit: I'd leave this in the header.

[szager1, 2016/01/12 21:19:51]

The target can only ever be an Element; only the root can be a Document.  The
IntersectionObservation constructor takes an Element argument, so this must be
an Element.

The only reason I didn't inline target() is because it would require adding
'#include "core/dom/Element.h"' to the header.  I don't feel strongly either
way, let me know what you prefer.

+}
+
 void IntersectionObservation::initializeGeometry(IntersectionGeometry& geometry)
 {
     ASSERT(m_target);
-    LayoutObject* targetLayoutObject = m_target->layoutObject();
+    LayoutObject* targetLayoutObject = target()->layoutObject();
     if (targetLayoutObject->isBoxModelObject())
         geometry.targetRect = toLayoutBoxModelObject(targetLayoutObject)->visualOverflowRect();
     else
         geometry.targetRect = toLayoutText(targetLayoutObject)->visualOverflowRect();
     geometry.intersectionRect = geometry.targetRect;
 }
 
 void IntersectionObservation::clipToRoot(LayoutRect& rect)
 {
     // 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 = m_target->layoutObject();
+    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);
         rootLayoutBox->flipForWritingMode(rect);
         rect.intersect(clipRect);
         rootLayoutBox->flipForWritingMode(rect);
     }
 }
 
 void IntersectionObservation::clipToFrameView(IntersectionGeometry& geometry)
 {
-    Element* rootElement = m_observer->root();
+    Node* rootNode = m_observer->root();
     LayoutObject* rootLayoutObject = m_observer->rootLayoutObject();
-    if (rootElement == rootElement->document().documentElement()) {
-        geometry.rootRect = LayoutRect(rootElement->document().view()->visibleContentRect());
+    if (rootLayoutObject->isLayoutView()) {
+        geometry.rootRect = LayoutRect(toLayoutView(rootLayoutObject)->frameView()->visibleContentRect());
         m_observer->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);
     }
 
-    LayoutPoint scrollPosition(rootElement->document().view()->scrollPosition());
+    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());
 }
 
 bool IntersectionObservation::computeGeometry(IntersectionGeometry& geometry)
 {
     ASSERT(m_target);
     LayoutObject* rootLayoutObject = m_observer->rootLayoutObject();
-    LayoutObject* targetLayoutObject = m_target->layoutObject();
+    LayoutObject* targetLayoutObject = target()->layoutObject();
     if (!rootLayoutObject->isBoxModelObject())
         return false;
     if (!targetLayoutObject->isBoxModelObject() && !targetLayoutObject->isText())
         return false;
 
     // Initialize targetRect and intersectionRect to bounds of target, in target's coordinate space.
     initializeGeometry(geometry);
 
     // TODO(szager): Support intersection observations for zero-area targets.  For now, we just
     // punt on the observation.
@@ skipping 48 matching lines @@
             pixelSnappedIntRect(geometry.intersectionRect),
             targetElement);
         observer().enqueueIntersectionObserverEntry(*newEntry);
     }
     setLastThresholdIndex(newThresholdIndex);
 }
 
 void IntersectionObservation::disconnect()
 {
     if (m_target)
-        m_target->ensureIntersectionObserverData().removeObservation(this->observer());
+        target()->ensureIntersectionObserverData().removeObservation(this->observer());
     m_observer->removeObservation(*this);
     m_observer.clear();
 }
 
 DEFINE_TRACE(IntersectionObservation)
 {
     visitor->trace(m_observer);
     visitor->trace(m_target);
 }
 
 } // namespace blink