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

third_party/WebKit/Source/core/dom/IntersectionObserver.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/IntersectionObserver.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/css/parser/CSSParserTokenRange.h"
 #include "core/css/parser/CSSTokenizer.h"
-#include "core/dom/ElementIntersectionObserverData.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/IntersectionObserverCallback.h"
 #include "core/dom/IntersectionObserverController.h"
 #include "core/dom/IntersectionObserverEntry.h"
 #include "core/dom/IntersectionObserverInit.h"
+#include "core/dom/NodeIntersectionObserverData.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/LayoutView.h"
 #include "platform/Timer.h"
 #include "wtf/MainThread.h"
 #include <algorithm>
 
 namespace blink {
 
 static void parseRootMargin(String rootMarginParameter, Vector<Length>& rootMargin, ExceptionState& exceptionState)
 {
@@ skipping 47 matching lines @@
             exceptionState.throwTypeError("Threshold values must be between 0 and 1");
             break;
         }
     }
 
     std::sort(thresholds.begin(), thresholds.end());
 }
 
 IntersectionObserver* IntersectionObserver::create(const IntersectionObserverInit& observerInit, IntersectionObserverCallback& callback, ExceptionState& exceptionState)
 {
-    RefPtrWillBeRawPtr<Element> root = observerInit.root();
+    RefPtrWillBeRawPtr<Node> root = observerInit.root();
     if (!root) {
         // TODO(szager): Use Document instead of document element for implicit root. (crbug.com/570538)
         ExecutionContext* context = callback.executionContext();
         ASSERT(context->isDocument());
         Frame* mainFrame = toDocument(context)->frame()->tree().top();
         if (mainFrame && mainFrame->isLocalFrame())
-            root = toLocalFrame(mainFrame)->document()->documentElement();
+            root = toLocalFrame(mainFrame)->document();
     }
     if (!root) {
-        exceptionState.throwDOMException(HierarchyRequestError, "Unable to get root element in main frame to track.");
+        exceptionState.throwDOMException(HierarchyRequestError, "Unable to get root node in main frame to track.");
         return nullptr;
     }
 
     Vector<Length> rootMargin;
     if (observerInit.hasRootMargin())
         parseRootMargin(observerInit.rootMargin(), rootMargin, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     Vector<float> thresholds;
     if (observerInit.hasThreshold())
         parseThresholds(observerInit.threshold(), thresholds, exceptionState);
     else
         thresholds.append(0);
     if (exceptionState.hadException())
         return nullptr;
 
     return new IntersectionObserver(callback, *root, rootMargin, thresholds);
 }
 
-IntersectionObserver::IntersectionObserver(IntersectionObserverCallback& callback, Element& root, const Vector<Length>& rootMargin, const Vector<float>& thresholds)
+IntersectionObserver::IntersectionObserver(IntersectionObserverCallback& callback, Node& root, const Vector<Length>& rootMargin, const Vector<float>& thresholds)
     : m_callback(&callback)
-    , m_root(root.ensureIntersectionObserverData().createWeakPtr(&root))
     , m_thresholds(thresholds)
     , m_topMargin(Fixed)
     , m_rightMargin(Fixed)
     , m_bottomMargin(Fixed)
     , m_leftMargin(Fixed)
 {
+    if (root.isDocumentNode())
+        m_root = toDocument(root).ensureIntersectionObserverData().createWeakPtr(&root);
+    else
+        m_root = toElement(root).ensureIntersectionObserverData().createWeakPtr(&root);
     switch (rootMargin.size()) {
     case 0:
         break;
     case 1:
         m_topMargin = m_rightMargin = m_bottomMargin = m_leftMargin = rootMargin[0];
         break;
     case 2:
         m_topMargin = m_bottomMargin = rootMargin[0];
         m_rightMargin = m_leftMargin = rootMargin[1];
         break;
     case 3:
         m_topMargin = rootMargin[0];
         m_rightMargin = m_leftMargin = rootMargin[1];
         m_bottomMargin = rootMargin[2];
         break;
     case 4:
         m_topMargin = rootMargin[0];
         m_rightMargin = rootMargin[1];
         m_bottomMargin = rootMargin[2];
         m_leftMargin = rootMargin[3];
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
     root.document().ensureIntersectionObserverController().addTrackedObserver(*this);
 }
 
-LayoutObject* IntersectionObserver::rootLayoutObject()
+LayoutObject* IntersectionObserver::rootLayoutObject() const
 {
-    Element* rootElement = root();
-    if (rootElement == rootElement->document().documentElement())
-        return rootElement->document().layoutView();
-    return rootElement->layoutObject();
+    Node* rootNode = root();
+    if (rootNode->isDocumentNode())
+        return toDocument(rootNode)->layoutView();
+    return toElement(rootNode)->layoutObject();
 }
 
 bool IntersectionObserver::isDescendantOfRoot(const Element* target) const
 {
     // Is m_root an ancestor, through the DOM and frame trees, of target?
-    Element* rootElement = m_root.get();
-    if (!rootElement || !target || target == rootElement)
+    Node* rootNode = root();
+    if (!rootNode || !target || target == rootNode)
         return false;
-    if (!target->inDocument() || !rootElement->inDocument())
+    if (!target->inDocument() || !rootNode->inDocument())
         return false;
 
-    Document* rootDocument = &rootElement->document();
+    Document* rootDocument = &rootNode->document();
     Document* targetDocument = &target->document();
     while (targetDocument != rootDocument) {
         target = targetDocument->ownerElement();
         if (!target)
             return false;
         targetDocument = &target->document();
     }
-    return target->isDescendantOf(rootElement);
+    if (rootNode->isDocumentNode()) {
+        ASSERT(targetDocument == rootNode);
+        return true;
+    }
+    return target->isDescendantOf(rootNode);
 }
 
 void IntersectionObserver::observe(Element* target, ExceptionState& exceptionState)
 {
     checkRootAndDetachIfNeeded();
     if (!m_root) {
         exceptionState.throwDOMException(HierarchyRequestError, "Invalid observer: root element or containing document has been deleted.");
         return;
     }
     if (!target) {
@@ skipping 148 matching lines @@
 
 DEFINE_TRACE(IntersectionObserver)
 {
     visitor->trace(m_callback);
     visitor->trace(m_root);
     visitor->trace(m_observations);
     visitor->trace(m_entries);
 }
 
 } // namespace blink