IntersectionObserver: second cut.

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

Index: third_party/WebKit/Source/core/dom/IntersectionObserver.cpp
diff --git a/third_party/WebKit/Source/core/dom/IntersectionObserver.cpp b/third_party/WebKit/Source/core/dom/IntersectionObserver.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..49805febfa70b5853572f440ee22f6b8feb1a794
--- /dev/null
+++ b/third_party/WebKit/Source/core/dom/IntersectionObserver.cpp
@@ -0,0 +1,244 @@
+// 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/html/HTMLFrameOwnerElement.h"
+#include "core/layout/LayoutView.h"
+#include "platform/Timer.h"
+#include "wtf/MainThread.h"
+#include <algorithm>
+
+namespace blink {
+
+static void parseThresholds(const DoubleOrDoubleArray& thresholdParameter, Vector<float>& thresholds, ExceptionState& exceptionState)
+{
+    if (thresholdParameter.isDouble()) {
+        thresholds.append(static_cast<float>(thresholdParameter.getAsDouble()));
+    } else {
+        for (auto thresholdValue : thresholdParameter.getAsDoubleArray())
+            thresholds.append(static_cast<float>(thresholdValue));
+    }
+
+    for (auto thresholdValue : thresholds) {
+        if (thresholdValue < 0.0 || thresholdValue > 1.0) {
+            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();
+    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();
+    }
+    if (!root) {
+        exceptionState.throwDOMException(HierarchyRequestError, "Unable to get root element in main frame to track.");
+        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, thresholds);
+}
+
+IntersectionObserver::IntersectionObserver(IntersectionObserverCallback& callback, Element& root, const Vector<float>& thresholds)
+    : m_callback(&callback)
+    , m_root(root.ensureIntersectionObserverData().createWeakPtr(&root))
+    , m_thresholds(thresholds)
+{
+    root.document().ensureIntersectionObserverController().addTrackedObserver(*this);
+}
+
+LayoutObject* IntersectionObserver::rootLayoutObject()
+{
+    Element* rootElement = root();
+    if (rootElement == rootElement->document().documentElement())
+        return rootElement->document().layoutView();
+    return rootElement->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)
+        return false;
+    if (!target->inDocument() || !rootElement->inDocument())
+        return false;
+
+    Document* rootDocument = &rootElement->document();
+    Document* targetDocument = &target->document();
+    while (targetDocument != rootDocument) {
+        target = targetDocument->ownerElement();
+        if (!target)
+            return false;
+        targetDocument = &target->document();
+    }
+    return target->isDescendantOf(rootElement);
+}
+
+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) {
+        exceptionState.throwTypeError("Observation target must be an element.");
+        return;
+    }
+    if (m_root.get() == target) {
+        exceptionState.throwDOMException(HierarchyRequestError, "Cannot use the same element for root and target.");
+        return;
+    }
+    if (!isDescendantOfRoot(target)) {
+        exceptionState.throwDOMException(HierarchyRequestError, "Observed element must be a descendant of the observer's root element.");
+        return;
+    }
+
+    bool shouldReportRootBounds = target->document().frame()->securityContext()->securityOrigin()->canAccess(root()->document().frame()->securityContext()->securityOrigin());
+
+    if (target->ensureIntersectionObserverData().getObservationFor(*this))
+        return;
+
+    IntersectionObservation* observation = new IntersectionObservation(*this, *target, shouldReportRootBounds);
+    target->ensureIntersectionObserverData().addObservation(*observation);
+    m_observations.add(observation);
+}
+
+void IntersectionObserver::unobserve(Element* target, ExceptionState&)
+{
+    checkRootAndDetachIfNeeded();
+    if (!target || !target->intersectionObserverData())
+        return;
+    // TODO(szager): unobserve callback
+    if (IntersectionObservation* observation = target->intersectionObserverData()->getObservationFor(*this))
+        observation->disconnect();
+}
+
+void IntersectionObserver::computeIntersectionObservations(double timestamp)
+{
+    checkRootAndDetachIfNeeded();
+    if (!m_root)
+        return;
+    for (auto& observation : m_observations)
+        observation->computeIntersectionObservations(timestamp);
+}
+
+void IntersectionObserver::disconnect()
+{
+    HeapVector<Member<IntersectionObservation>> observationsToDisconnect;
+    copyToVector(m_observations, observationsToDisconnect);
+    for (auto& observation : observationsToDisconnect)
+        observation->disconnect();
+    ASSERT(m_observations.isEmpty());
+    m_root.clear();
+}
+
+HeapVector<Member<IntersectionObserverEntry>> IntersectionObserver::takeRecords()
+{
+    checkRootAndDetachIfNeeded();
+    HeapVector<Member<IntersectionObserverEntry>> entries;
+    entries.swap(m_entries);
+    return entries;
+}
+
+void IntersectionObserver::enqueueIntersectionObserverEntry(IntersectionObserverEntry& entry)
+{
+    m_entries.append(&entry);
+    toDocument(m_callback->executionContext())->ensureIntersectionObserverController().scheduleIntersectionObserverForDelivery(*this);
+}
+
+unsigned IntersectionObserver::firstThresholdGreaterThan(float ratio) const
+{
+    unsigned result = 0;
+    while (result < m_thresholds.size() && m_thresholds[result] < ratio)
+        ++result;
+    return result;
+}
+
+bool IntersectionObserver::shouldBeSuspended() const

[haraken, 2016/01/07 00:48:17]

Factor out this method to a follow-up CL.

[szager1, 2016/01/07 07:12:22]

Done.

+{
+    return m_callback->executionContext() && m_callback->executionContext()->activeDOMObjectsAreSuspended();
+}
+
+void IntersectionObserver::deliver()
+{
+    checkRootAndDetachIfNeeded();
+
+    ASSERT(!shouldBeSuspended());
+
+    if (m_entries.isEmpty())
+        return;
+
+    HeapVector<Member<IntersectionObserverEntry>> entries;
+    entries.swap(m_entries);
+    m_callback->handleEvent(entries, *this);
+}
+
+void IntersectionObserver::setActive(bool active)
+{
+    checkRootAndDetachIfNeeded();
+    for (auto& observation : m_observations)
+        observation->setActive(m_root && active && isDescendantOfRoot(observation->target()));
+}
+
+void IntersectionObserver::checkRootAndDetachIfNeeded()

[haraken, 2016/01/07 00:48:17]

This implementation is clearly wrong in oilpan. We should add registerWeakMember
to Observer::m_root and call the disconnect in the weak callback.

We have agreed on fixing the issue in a follow-up CL.

[szager1, 2016/01/07 07:12:22]

Acknowledged.

+{
+#if ENABLE(OILPAN)
+    // TODO(szager): Pre-oilpan, ElementIntersectionObserverData::dispose() will take
+    // care of this cleanup.  When oilpan ships, there will be a potential leak of the
+    // callback's execution context when the root goes away.  For a detailed explanation:
+    //
+    //   https://goo.gl/PC2Baj
+    //
+    // When that happens, this method should catch most potential leaks, but a complete
+    // solution will still be needed, along the lines described in the above link.
+
+    // TODO(szager): As a performance optimization, clear the hash tables before disconnecting

[haraken, 2016/01/07 00:48:17]

Remove this TODO.

[szager1, 2016/01/07 07:12:22]

Done.

+    // the observations, and avoid hash lookups in IntersectionObservation::detach.
+    // That would make the ASSERT superfluous, but let's leave it as is for a while
+    // to see if the ASSERT ever fails.
+    if (m_root)
+        return;
+    disconnect();
+#endif
+}
+
+DEFINE_TRACE(IntersectionObserver)
+{
+    visitor->trace(m_callback);
+    visitor->trace(m_root);
+    visitor->trace(m_observations);
+    visitor->trace(m_entries);
+}
+
+} // namespace blink