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..03caca769f326d33d116f48087f53bed8587f20a
--- /dev/null
+++ b/third_party/WebKit/Source/core/dom/IntersectionObserver.cpp
@@ -0,0 +1,270 @@
+// Copyright 2015 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 "config.h"
+#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/ExceptionCode.h"
+#include "core/dom/ExecutionContext.h"
+#include "core/dom/IntersectionObserverCallback.h"
+#include "core/dom/IntersectionObserverEntry.h"
+#include "core/dom/IntersectionObserverInit.h"
+#include "core/dom/IntersectionObserverRegistry.h"
+#include "core/html/HTMLFrameOwnerElement.h"
+#include "platform/Timer.h"
+#include "wtf/MainThread.h"
+#include <algorithm>
+
+namespace blink {
+
+IntersectionObserver* IntersectionObserver::create(const IntersectionObserverInit& observerInit, IntersectionObserverCallback* callback, ExceptionState& exceptionState)
+{
+    ASSERT(isMainThread());
+
+    RefPtrWillBeRawPtr<Element> root = observerInit.root();
+    if (!root) {
+        ASSERT(callback);
+        ExecutionContext* context = callback->executionContext();
+        if (context->isDocument()) {
+            Frame* mainFrame = static_cast<Document*>(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;
+    }
+
+    int rootMargin = 0;
+    if (observerInit.hasRootMargin()) {
+        CSSTokenizer::Scope tokenizerScope(observerInit.rootMargin());
+        CSSParserTokenRange tokenRange = tokenizerScope.tokenRange();
+        const CSSParserToken& token = tokenRange.consumeIncludingWhitespace();
+        switch (token.type()) {
+        case EOFToken:
+            break;
+        case NumberToken:
+            rootMargin = static_cast<int>(floor(token.numericValue()));
+            break;
+        case DimensionToken:
+            switch (token.unitType()) {
+            case CSSPrimitiveValue::UnitType::Number:
+            case CSSPrimitiveValue::UnitType::Pixels:
+                rootMargin = static_cast<int>(token.numericValue());
+                break;
+            default:
+                exceptionState.throwTypeError("rootMargin must be specified in pixels.");
+                break;
+            }
+            break;
+        default:
+            exceptionState.throwTypeError("rootMargin must be specified in pixels.");
+        }
+    }
+    if (exceptionState.hadException())
+        return nullptr;
+
+    Vector<float> thresholds;
+    if (observerInit.hasThreshold()) {
+        const DoubleOrDoubleArray& thresholdParam = observerInit.threshold();
+        if (thresholdParam.isDouble()) {
+            thresholds.append(static_cast<float>(thresholdParam.getAsDouble()));
+        } else {
+            for (auto thresholdValue: thresholdParam.getAsDoubleArray())
+                thresholds.append(static_cast<float>(thresholdValue));
+        }
+    } else {
+        thresholds.append(0);
+    }
+    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());
+    if (exceptionState.hadException())
+        return nullptr;
+
+    return new IntersectionObserver(callback, root.get(), rootMargin, thresholds);
+}
+
+IntersectionObserver::IntersectionObserver(IntersectionObserverCallback* callback, Element* root, int rootMargin, const Vector<float>& thresholds)
+    : m_callback(callback)
+    , m_root(root->createWeakPtr())
+    , m_observations(new IntersectionObservation::WeakHashSet())
+    , m_entries(new IntersectionObserverEntryVector())
+    , m_thresholds(thresholds)
+    , m_rootMargin(rootMargin)
+{
+    root->document().intersectionObserverRegistry()->addTrackedObserver(*this);
+}
+
+bool IntersectionObserver::isDescendantOfRoot(Element* target)
+{
+    checkRootAndDetachIfNecessary();
+    Element* rootElement = m_root.get();
+    if (!rootElement)
+        return false;
+
+    if (target == rootElement || !target->inDocument() || !rootElement->inDocument())
+        return false;
+    LocalFrame* rootFrame = rootElement->document().frame();
+    LocalFrame* targetFrame = target->document().frame();
+    if (!rootFrame || !targetFrame || !targetFrame->tree().isDescendantOf(rootFrame))
+        return false;
+    while (targetFrame != rootFrame) {
+        FrameOwner* targetOwner = targetFrame->owner();
+        if (!targetOwner || !targetOwner->isLocal())
+            return false;
+        target = toHTMLFrameOwnerElement(targetOwner);
+        ASSERT(target);
+        targetFrame = target->document().frame();
+        if (!targetFrame)
+            return false;
+    }
+    return target->isDescendantOf(rootElement);
+}
+
+void IntersectionObserver::observe(Element* target, ExceptionState& exceptionState)
+{
+    checkRootAndDetachIfNecessary();

[dcheng, 2015/12/10 00:37:09]

Similarly, I don't think weak pointers is making this simpler. Now, in each
method, we need to check if we've already been detached and make sure to clean
up in that case. This makes it hard to understand when the cleanup actually
runs.

It's very much Blink style to explicitly detach things when needed: there's a
lot of existing code that does this (LocalFrame<->FrameView, WebLocalFrameImpl,
and many other things) and I think we should continue using that pattern when
possible.

The one potential problem for IntersectionObserver with Oilpan is that you'd
want to null out m_root on Document destruction. This can't happen in ~Document,
since IntersectionObserver is also a heap object. The good news is that
Documents can't be reattached, so that work can just be done in
Document::detach() instead.

[szager1, 2015/12/10 22:38:55]

The correct place to do this cleanup is when the root element is gc'ed. 
Unfortunately, there's no way in oilpan to do anything meaningful like this in a
destructor.  Were it possible to do this in the Element destructor, I could get
rid of checkRootAndDetachIfNecessary entirely.  Alas.

+    if (!m_root)
+        exceptionState.throwDOMException(HierarchyRequestError, "Invalid observer: root element or containing document has been deleted.");
+    else if (!target)
+        exceptionState.throwTypeError("Observation target must be an element.");
+    else if (m_root.get() == target)
+        exceptionState.throwDOMException(HierarchyRequestError, "Cannot use the same element for root and target.");
+    else if (!isDescendantOfRoot(target))
+        exceptionState.throwDOMException(HierarchyRequestError, "Observed element must be a descendant of the observer's root element.");
+    if (exceptionState.hadException())
+        return;
+
+    if (IntersectionObservation::contains(*m_observations, this, target))
+        return;
+
+    createObservation(target);
+}
+
+void IntersectionObserver::unobserve(Element* target, ExceptionState&)
+{
+    checkRootAndDetachIfNecessary();
+    if (!target)
+        return;
+    IntersectionObservation::WeakHashSet::iterator observationIterator = IntersectionObservation::find(*m_observations, this, target);
+    // TODO: unobserve callback
+    if (observationIterator != m_observations->end())
+        (*observationIterator)->disconnect();
+}
+
+void IntersectionObserver::computeIntersectionObservations(int timestamp)
+{
+    checkRootAndDetachIfNecessary();
+    if (!m_root)
+        return;
+    for (auto& observation: *m_observations)
+        observation->computeIntersectionObservations(timestamp);
+}
+
+void IntersectionObserver::disconnect(IntersectionObservation& observation)
+{
+    m_observations->remove(&observation);
+}
+
+void IntersectionObserver::disconnect()
+{
+    checkRootAndDetachIfNecessary();
+    HeapVector<Member<IntersectionObservation>> toDisconnect;
+    for (auto& observation: *m_observations)
+        toDisconnect.append(observation);
+    for (auto& observation: toDisconnect)
+        observation->disconnect();
+    ASSERT(!m_observations->size());
+}
+
+IntersectionObserverEntryVector IntersectionObserver::takeRecords()
+{
+    checkRootAndDetachIfNecessary();
+    IntersectionObserverEntryVector entries;
+    entries.swap(*m_entries);
+    return entries;
+}
+
+void IntersectionObserver::enqueueIntersectionObserverEntry(IntersectionObserverEntry* entry)
+{
+    ASSERT(isMainThread());
+    m_entries->append(entry);
+    static_cast<Document*>(m_callback->executionContext())->intersectionObserverRegistry()->scheduleIntersectionObserverForDelivery(*this);
+}
+
+size_t IntersectionObserver::firstThresholdGreaterThan(float ratio) const
+{
+    size_t result = 0;
+    size_t max = m_thresholds.size();
+    while (result < max && m_thresholds[result] < ratio)
+        ++result;
+    return result;
+}
+
+bool IntersectionObserver::shouldBeSuspended() const
+{
+    return m_callback->executionContext() && m_callback->executionContext()->activeDOMObjectsAreSuspended();
+}
+
+void IntersectionObserver::deliver()
+{
+    checkRootAndDetachIfNecessary();
+
+    ASSERT(!shouldBeSuspended());
+
+    if (m_entries->isEmpty())
+        return;
+
+    IntersectionObserverEntryVector entries;
+    entries.swap(*m_entries);
+    m_callback->handleEvent(entries, this);
+}
+
+void IntersectionObserver::setActive(bool active)
+{
+    checkRootAndDetachIfNecessary();
+    for (auto& observation: *m_observations)
+        observation->setActive(m_root && active && isDescendantOfRoot(observation->target()));
+}
+
+IntersectionObservation* IntersectionObserver::createObservation(Element* target)
+{
+    IntersectionObservation* observation = new IntersectionObservation(*this, target);
+    m_observations->add(observation);
+    return observation;
+}
+
+void IntersectionObserver::checkRootAndDetachIfNecessary()
+{
+    if (m_root)
+        return;
+    m_callback.clear();
+    HeapVector<Member<IntersectionObservation>> toDisconnect;
+    for (auto& observation: *m_observations)
+        toDisconnect.append(observation);
+    for (auto& observation: toDisconnect)
+        observation->disconnect();
+    ASSERT(!m_observations->size());
+    // TODO: should we deliver pending notifications?
+    m_entries.clear();
+}
+
+DEFINE_TRACE(IntersectionObserver)
+{
+    visitor->trace(m_callback);
+    visitor->trace(m_root);
+    visitor->trace(m_observations);
+    visitor->trace(m_entries);
+}
+
+} // namespace blink