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 "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()) {

[haraken, 2015/12/22 01:13:30]

Where does 5 come from?

[esprehn, 2015/12/22 07:50:32]

It's parsing a sequence of lengths, this could use a comment.

It wants to accept:

5px = all sides
5px 5px = top bottom
5px 5px 5px = top left/right bottom
5px 5px 5px 5px = top right left bottom

See:
https://developer.mozilla.org/en-US/docs/Web/CSS/margin#Syntax

[szager1, 2015/12/22 07:53:41]

It accepts syntax similar to padding, e.g.:

"1px"
"1px 2px"
"1px 2px 3px"
"1px 2px 3px 4px"

Currently, it ignores any extra stuff at the end.

[szager1, 2015/12/22 08:49:50]

Added comment.

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

[haraken, 2015/12/22 01:13:30]

It would be helpful to have a comment to explain what the "root" means.

[esprehn, 2015/12/22 07:50:33]

It's the m_root member variable. The only special part this method checks is
that it crosses frame boundaries.

[szager1, 2015/12/22 07:53:41]

Added a comment.

+{
+    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 (!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->ensureIntersectionObserverData().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(szager): unobserve callback
+    target->ensureIntersectionObserverData().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)

[haraken, 2015/12/22 01:13:30]

Nit: We can just pass IntersectionObservation* instead of
IntersectionObservation&.

[szager1, 2015/12/22 07:53:41]

This is contrary to esprehn's comments.

+{
+    m_observations.remove(&observation);

[haraken, 2015/12/22 01:13:30]

Add ASSERT(m_observations.contains(observation)).

[szager1, 2015/12/22 07:53:41]

Done.

[szager1, 2015/12/22 19:04:36]

Actually, no, that's a bad ASSERT.  Because m_observations is a hash set of weak
pointers, it's possible (and it's OK) for the observation to be missing.

+}
+
+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();

[esprehn, 2015/12/22 07:50:33]

having to call this in each method still feels wrong, Can we use an Oilpan Weak
callback instead? Can you add a TODO to this manual clean up method?

Other features should not be following this pattern.

[szager1, 2015/12/22 08:49:50]

I agree wholeheartedly, that is the next thing I plan to work on.  There is
already a TODO on the method definition.

+    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)

[esprehn, 2015/12/22 07:50:33]

can this return LayoutUnit instead?

[szager1, 2015/12/22 08:49:50]

Done.

+{
+    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);

[esprehn, 2015/12/22 07:50:32]

LayoutRect is of LayoutUnit, so you convert from LayoutUnit above to int and
then back to LayoutUnit, can we stay in LayoutUnit space without doing that
conversion?

[szager1, 2015/12/22 08:49:50]

Done.

+    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);
+}
+
+#if !ENABLE(OILPAN)
+void IntersectionObserver::dispose()
+{
+    m_root.clear();
+    checkRootAndDetachIfNeeded();
+}
+#endif
+
+void IntersectionObserver::checkRootAndDetachIfNeeded()
+{
+#if ENABLE(OILPAN)
+    // TODO(szager): Pre-oilpan, ElementIntersectionObserverData::dispose() will take

[haraken, 2015/12/22 01:13:30]

I'm concerned about this but will comment on it after other lifetime issues are
resolved :)

[esprehn, 2015/12/22 07:50:32]

Yeah this doesn't seem like something we want with Oilpan, how can we fix this
feature or Oilpan? I think what's missing here is weak processing callbacks?

[szager1, 2015/12/22 07:53:41]

Just to be clear: I don't think your current round of comments on this CL have
raised any new issues about lifetime management, so please do weigh in on this
method.

[szager1, 2015/12/22 08:49:50]

registerWeakMembers looks like it might work here, I'm investigating.

+    // 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
+    // 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;
+    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(szager): should we deliver pending notifications?

[esprehn, 2015/12/22 07:50:33]

Pending records need to keep the root alive, otherwise there's no way to compute
the data about the root like the bounds. So m_root should never be collected
while there's records awaiting delivery. We might need to change the ownership
model to make that work.

[szager1, 2015/12/22 08:49:50]

Once I figure out a non-leaky fix for the root lifetime issue, it shouldn't be
necessary to do this.

+    m_entries.clear();
+#endif
+}
+
+DEFINE_TRACE(IntersectionObserver)
+{
+    visitor->trace(m_callback);
+    visitor->trace(m_root);
+    visitor->trace(m_observations);
+    visitor->trace(m_entries);
+}
+
+} // namespace blink