IntersectionObserver: second cut.

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

+// 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/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 parseRootMargin(String rootMarginParameter, Vector<Length>& rootMargin, ExceptionState& exceptionState)
+{
+    CSSTokenizer::Scope tokenizerScope(rootMarginParameter);
+    CSSParserTokenRange tokenRange = tokenizerScope.tokenRange();
+    while (rootMargin.size() < 5 && tokenRange.peek().type() != EOFToken && !exceptionState.hadException()) {
+        const CSSParserToken& token = tokenRange.consumeIncludingWhitespace();
+        switch (token.type()) {
+        case PercentageToken:
+            rootMargin.append(Length(token.numericValue(), Percent));
+            break;
+        case DimensionToken:
+            switch (token.unitType()) {
+            case CSSPrimitiveValue::UnitType::Pixels:
+                rootMargin.append(Length(static_cast<int>(floor(token.numericValue())), Fixed));
+                break;
+            case CSSPrimitiveValue::UnitType::Percentage:
+                rootMargin.append(Length(token.numericValue(), Percent));
+                break;
+            default:
+                exceptionState.throwTypeError("rootMargin must be specified in pixels or percent.");
+            }
+            break;
+        default:
+            exceptionState.throwTypeError("rootMargin must be specified in pixels or percent.");
+        }
+    }
+}
+
+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) {
+        ExecutionContext* context = callback.executionContext();
+        ASSERT(context->isDocument());
+        Frame* mainFrame = toDocument(context)->frame()->tree().top();
+        if (mainFrame && mainFrame->isLocalFrame())
+            root = toLocalFrame(mainFrame)->document()->documentElement();

[esprehn, 2015/12/17 01:40:28]

Add a TODO and maybe link to that new bug?

[szager1, 2015/12/17 20:27:26]

Done.

+    }
+    if (!root) {
+        exceptionState.throwDOMException(HierarchyRequestError, "Unable to get root element 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)
+    : m_callback(&callback)
+    , m_root(root.intersectionObserverData().createWeakPtr(&root))
+    , m_thresholds(thresholds)
+{
+    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;
+    default:

[esprehn, 2015/12/17 01:40:28]

case 4:

and the default should ASSERT_NOT_REACHED() ?

[szager1, 2015/12/17 20:27:26]

Done.

+        m_topMargin = rootMargin[0];
+        m_rightMargin = rootMargin[1];
+        m_bottomMargin = rootMargin[2];
+        m_leftMargin = rootMargin[3];
+        break;

[esprehn, 2015/12/17 01:40:28]

I feel like we should be able to ASSERT_NOT_REACHED() for the case of > 4, since
there's no way the CSS parser should allow that.

[szager1, 2015/12/17 20:27:26]

Done.

+    }
+    root.document().intersectionObserverController()->addTrackedObserver(*this);
+}
+
+LayoutObject* IntersectionObserver::rootLayoutObject()
+{
+    Element* rootElement = root();
+    bool rootIsDocumentElement = (rootElement == rootElement->document().documentElement());

[esprehn, 2015/12/17 01:40:28]

break this apart.

if (rootElement == rootElement->document().documentElement())
    return rootElement->document().layoutView();
return rootElement->layoutObject();

[szager1, 2015/12/17 20:27:26]

Done.

+    return rootIsDocumentElement ? rootElement->document().layoutView() : rootElement->layoutObject();
+}
+
+bool IntersectionObserver::isDescendantOfRoot(const Element* target) const
+{
+    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.");

[esprehn, 2015/12/17 01:40:29]

I do kind of wonder if we should relax this in the spec, this means you can't
observe a widget before you insert it which seems a little silly. We can sort
that out after this lands though.

[szager1, 2015/12/17 20:27:26]

Acknowledged.

+        return;
+    }
+
+    bool shouldReportRootBounds = target->document().frame()->securityContext()->securityOrigin()->canAccess(root()->document().frame()->securityContext()->securityOrigin());
+    if (!shouldReportRootBounds && hasPercentMargin()) {
+        exceptionState.throwDOMException(HierarchyRequestError, "Cannot observe a cross-origin target because the observer has a root margin value specified as a percent.");
+        return;
+    }
+
+    if (target->intersectionObserverData().hasObservationFor(*this))
+        return;
+
+    IntersectionObservation* observation = new IntersectionObservation(*this, *target, shouldReportRootBounds);
+    m_observations.add(observation);
+}
+
+void IntersectionObserver::unobserve(Element* target, ExceptionState&)
+{
+    checkRootAndDetachIfNeeded();
+    if (!target || !target->hasIntersectionObserverData())
+        return;
+    // TODO: unobserve callback

[esprehn, 2015/12/17 01:40:28]

TODO(szager):

It's good to attribute your TODO's now

[szager1, 2015/12/17 20:27:26]

Done, here and elsewhere.

+    target->intersectionObserverData().removeObservation(*this);
+}
+
+void IntersectionObserver::computeIntersectionObservations(double timestamp)
+{
+    checkRootAndDetachIfNeeded();
+    if (!m_root)
+        return;
+    for (auto& observation : m_observations)
+        observation->computeIntersectionObservations(timestamp);
+}
+
+void IntersectionObserver::disconnect(IntersectionObservation& observation)
+{
+    m_observations.remove(&observation);
+}
+
+void IntersectionObserver::disconnect()
+{
+    checkRootAndDetachIfNeeded();
+    HeapVector<Member<IntersectionObservation>> toDisconnect;
+    for (auto& observation : m_observations)
+        toDisconnect.append(observation);
+    for (auto& observation : toDisconnect)
+        observation->disconnect();
+    ASSERT(m_observations.isEmpty());
+}
+
+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())->intersectionObserverController()->scheduleIntersectionObserverForDelivery(*this);
+}
+
+static int computeMargin(const Length& length, LayoutUnit referenceLength)
+{
+    if (length.type() == Percent)
+        return static_cast<int>(referenceLength.toFloat() * length.percent() / 100.0);
+    return length.intValue();
+}
+
+void IntersectionObserver::applyRootMargin(LayoutRect& rect) const
+{
+    int topMargin = computeMargin(m_topMargin, rect.height());
+    int rightMargin = computeMargin(m_rightMargin, rect.width());
+    int bottomMargin = computeMargin(m_bottomMargin, rect.height());
+    int leftMargin = computeMargin(m_leftMargin, rect.width());
+
+    rect.setX(rect.x() - leftMargin);
+    rect.setWidth(rect.width() + leftMargin + rightMargin);
+    rect.setY(rect.y() - topMargin);
+    rect.setHeight(rect.height() + topMargin + bottomMargin);
+}
+
+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
+{
+    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()));
+}
+
+bool IntersectionObserver::hasPercentMargin() const
+{
+    return m_topMargin.type() == Percent || m_rightMargin.type() == Percent || m_bottomMargin.type() == Percent || m_leftMargin.type() == Percent;

[esprehn, 2015/12/17 01:40:29]

I'd wrap each || so this is multiple lines

[szager1, 2015/12/17 20:27:26]

Done.

+}
+
+#if !ENABLE(OILPAN)
+void IntersectionObserver::dispose()
+{
+    m_root.clear();
+    checkRootAndDetachIfNeeded();
+}
+#endif
+
+void IntersectionObserver::checkRootAndDetachIfNeeded()

[esprehn, 2015/12/17 01:40:29]

hmm, I think I need to understand why you need to check this all the time in
each method? This is because you don't have a callback when the weak handle goes
away?

I wonder if we can fix this in Oilpan, having to do all this manual checking is
sad

[szager1, 2015/12/17 20:27:26]

Now that there's ElementIntersectionObserverData::dispose(), I can "#if
ENABLE(OILPAN)" the contents of this method out for now (done).

Once oilpan ships, dcheng's suggestion (or haraken's suggestion in the notes to
use registerWeakMemers) might work:

https://docs.google.com/a/chromium.org/document/d/1gmIi87dPJ0zu6XU7Jk2t8JS6b-...

I have to think about this a bit more, fortunately I have some time before
oilpan ships.

+{
+    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.isEmpty());
+    // 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