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

third_party/WebKit/Source/core/dom/NodeIntersectionObserverData.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/ElementIntersectionObserverData.h"
+#include "core/dom/NodeIntersectionObserverData.h"
 
 #include "core/dom/Document.h"
-#include "core/dom/Element.h"
 #include "core/dom/IntersectionObservation.h"
 #include "core/dom/IntersectionObserver.h"
 #include "core/dom/IntersectionObserverController.h"
 
 namespace blink {
 
-ElementIntersectionObserverData::ElementIntersectionObserverData() { }
+NodeIntersectionObserverData::NodeIntersectionObserverData() { }
 
-ElementIntersectionObserverData::~ElementIntersectionObserverData() { }
+NodeIntersectionObserverData::~NodeIntersectionObserverData() { }
 
-bool ElementIntersectionObserverData::hasIntersectionObserver() const
+bool NodeIntersectionObserverData::hasIntersectionObserver() const
 {
     return !m_intersectionObservers.isEmpty();
 }
 
-bool ElementIntersectionObserverData::hasIntersectionObservation() const
+bool NodeIntersectionObserverData::hasIntersectionObservation() const
 {
     return !m_intersectionObservations.isEmpty();
 }
 
-IntersectionObservation* ElementIntersectionObserverData::getObservationFor(IntersectionObserver& observer)
+IntersectionObservation* NodeIntersectionObserverData::getObservationFor(IntersectionObserver& observer)
 {
     auto i = m_intersectionObservations.find(&observer);
     if (i == m_intersectionObservations.end())
         return nullptr;
     return i->value;
 }
 
-void ElementIntersectionObserverData::addObservation(IntersectionObservation& observation)
+void NodeIntersectionObserverData::addObservation(IntersectionObservation& observation)
 {
     m_intersectionObservations.add(&observation.observer(), &observation);
 }
 
-void ElementIntersectionObserverData::removeObservation(IntersectionObserver& observer)
+void NodeIntersectionObserverData::removeObservation(IntersectionObserver& observer)
 {
     m_intersectionObservations.remove(&observer);
 }
 
-void ElementIntersectionObserverData::activateValidIntersectionObservers(Element& element)
+void NodeIntersectionObserverData::activateValidIntersectionObservers(Node& node)
 {
-    IntersectionObserverController& controller = element.document().ensureIntersectionObserverController();
+    IntersectionObserverController& controller = node.document().ensureIntersectionObserverController();
+    // Activate observers for which node is root.
     for (auto& observer : m_intersectionObservers) {
         controller.addTrackedObserver(*observer);
         observer->setActive(true);
     }
+    // A document can be root, but not target.
+    if (node.isDocumentNode())
+        return;
+    // Active observers for which node is target.
     for (auto& observation : m_intersectionObservations)
-        observation.value->setActive(observation.key->isDescendantOfRoot(&element));
+        observation.value->setActive(observation.key->isDescendantOfRoot(&toElement(node)));
 }
 
-void ElementIntersectionObserverData::deactivateAllIntersectionObservers(Element& element)
+void NodeIntersectionObserverData::deactivateAllIntersectionObservers(Node& node)
 {
-    element.document().ensureIntersectionObserverController().removeTrackedObserversForRoot(element);
+    node.document().ensureIntersectionObserverController().removeTrackedObserversForRoot(node);
     for (auto& observer : m_intersectionObservers)
         observer->setActive(false);
     for (auto& observation : m_intersectionObservations)
         observation.value->setActive(false);
 }
 
 #if !ENABLE(OILPAN)
-void ElementIntersectionObserverData::dispose()
+void NodeIntersectionObserverData::dispose()
 {
     HeapVector<Member<IntersectionObserver>> observersToDisconnect;
     copyToVector(m_intersectionObservers, observersToDisconnect);
     for (auto& observer : observersToDisconnect)
         observer->disconnect();
     ASSERT(m_intersectionObservers.isEmpty());
 }
 #endif
 
-WeakPtrWillBeRawPtr<Element> ElementIntersectionObserverData::createWeakPtr(Element* element)
+WeakPtrWillBeRawPtr<Node> NodeIntersectionObserverData::createWeakPtr(Node* node)
 {
 #if ENABLE(OILPAN)
-    return element;
+    return node;
 #else
     if (!m_weakPointerFactory)
-        m_weakPointerFactory = adoptPtrWillBeNoop(new WeakPtrFactory<Element>(element));
-    return m_weakPointerFactory->createWeakPtr();
+        m_weakPointerFactory = adoptPtrWillBeNoop(new WeakPtrFactory<Node>(node));
+    WeakPtr<Node> result = m_weakPointerFactory->createWeakPtr();
+    ASSERT(result.get() == node);
+    return result;
 #endif
 }
 
-DEFINE_TRACE(ElementIntersectionObserverData)
+DEFINE_TRACE(NodeIntersectionObserverData)
 {
     visitor->trace(m_intersectionObservers);
     visitor->trace(m_intersectionObservations);
 }
 
 } // namespace blink