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..37c3b802ba48a0dd7d9308b99eed740b6c9c4d8b |
--- /dev/null |
+++ b/third_party/WebKit/Source/core/dom/IntersectionObserver.cpp |
@@ -0,0 +1,364 @@ |
+// 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) |
+{ |
+ // The root margin argument accepts syntax similar to that for CSS margin: |
+ // |
+ // "1px" = top/right/bottom/left |
+ // "1px 2px" = top/bottom left/right |
+ // "1px 2px 3px" = top left/right bottom |
+ // "1px 2px 3px 4px" = top left right bottom |
+ // |
+ // Any extra stuff after the first four tokens is ignored. |
+ 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) { |
+ // 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().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 (!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); |
+ target->ensureIntersectionObserverData().addObservation(*observation); |
+ m_observations.add(observation); |
+} |
+ |
+void IntersectionObserver::unobserve(Element* target, ExceptionState&) |
+{ |
+ checkRootAndDetachIfNeeded(); |
+ if (!target || !target->intersectionObserverData()) |
+ 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
2016/01/02 13:47:40
As commented in IntersectionObserver::disconnect,
|
+{ |
+ m_observations.remove(&observation); |
+} |
+ |
+void IntersectionObserver::disconnect() |
+{ |
+ checkRootAndDetachIfNeeded(); |
+ HeapVector<Member<IntersectionObservation>> toDisconnect; |
+ for (auto& observation : m_observations) |
+ toDisconnect.append(observation); |
haraken
2016/01/02 13:47:40
Use copyToVector.
szager1
2016/01/02 19:18:34
Done.
|
+ 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())->ensureIntersectionObserverController().scheduleIntersectionObserverForDelivery(*this); |
+} |
+ |
+static LayoutUnit computeMargin(const Length& length, LayoutUnit referenceLength) |
+{ |
+ if (length.type() == Percent) |
+ return LayoutUnit(static_cast<int>(referenceLength.toFloat() * length.percent() / 100.0)); |
+ return LayoutUnit(length.intValue()); |
+} |
+ |
+void IntersectionObserver::applyRootMargin(LayoutRect& rect) const |
+{ |
+ LayoutUnit topMargin = computeMargin(m_topMargin, rect.height()); |
+ LayoutUnit rightMargin = computeMargin(m_rightMargin, rect.width()); |
+ LayoutUnit bottomMargin = computeMargin(m_bottomMargin, rect.height()); |
+ LayoutUnit 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 |
haraken
2016/01/02 13:47:40
To reduce the complexity of this CL, I'd propose n
szager1
2016/01/02 19:18:34
I'm a bit concerned that something could go very w
|
+{ |
+ 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() |
haraken
2016/01/02 13:47:40
I think you can remove this dispose method, for th
|
+{ |
+ m_root.clear(); |
+ checkRootAndDetachIfNeeded(); |
+} |
+#endif |
+ |
+void IntersectionObserver::checkRootAndDetachIfNeeded() |
+{ |
+#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 |
+ // 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? |
+ 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 |