Start autoplay muted videos with autoplay attribute when they are visible.

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

 // 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/Element.h"
@@ skipping 10 matching lines @@
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/layout/LayoutView.h"
 #include "core/timing/DOMWindowPerformance.h"
 #include "core/timing/Performance.h"
 #include "platform/Timer.h"
 #include <algorithm>
 
 namespace blink {
 
-static void parseRootMargin(String rootMarginParameter, Vector<Length>& rootMargin, ExceptionState& exceptionState)
+namespace {
+
+// Internal implementation of IntersectionObserverCallback when using
+// IntersectionObserver with an EventCallback.
+class IntersectionObserverCallbackImpl final : public IntersectionObserverCallback {
+    WTF_MAKE_NONCOPYABLE(IntersectionObserverCallbackImpl);
+public:
+    IntersectionObserverCallbackImpl(ExecutionContext* context, std::unique_ptr<IntersectionObserver::EventCallback> callback)
+        : m_context(context)
+        , m_callback(std::move(callback))
+    {}
+
+    void handleEvent(const HeapVector<Member<IntersectionObserverEntry>>& entries, IntersectionObserver&) override
+    {
+        (*m_callback.get())(entries);
+    }
+
+    ExecutionContext* getExecutionContext() const override
+    {
+        return m_context;
+    }
+
+    DEFINE_INLINE_TRACE()
+    {
+        IntersectionObserverCallback::trace(visitor);
+        visitor->trace(m_context);
+    }
+
+private:
+    WeakMember<ExecutionContext> m_context;
+    std::unique_ptr<IntersectionObserver::EventCallback> m_callback;
+};
+
+void parseRootMargin(String rootMarginParameter, Vector<Length>& rootMargin, ExceptionState& exceptionState)
 {
     // TODO(szager): Make sure this exact syntax and behavior is spec-ed somewhere.
 
     // 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
     //
@@ skipping 17 matching lines @@
             default:
                 exceptionState.throwDOMException(SyntaxError, "rootMargin must be specified in pixels or percent.");
             }
             break;
         default:
             exceptionState.throwDOMException(SyntaxError, "rootMargin must be specified in pixels or percent.");
         }
     }
 }
 
-static void parseThresholds(const DoubleOrDoubleArray& thresholdParameter, Vector<float>& thresholds, ExceptionState& exceptionState)
+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.throwRangeError("Threshold values must be between 0 and 1");
             break;
         }
     }
 
     std::sort(thresholds.begin(), thresholds.end());
 }
 
+// Returns the root Node of a given Document to use as the IntersectionObserver
+// root when no root is given.
+// TODO(szager): it doesn't support RemoteFrames, see https://crbug.com/615156
+Node* getRootNode(Document* document)
+{
+    Frame* mainFrame = document->frame()->tree().top();
+    if (mainFrame && mainFrame->isLocalFrame())
+        return toLocalFrame(mainFrame)->document();
+    return nullptr;
+}
+
+} // anonymous namespace
+
 IntersectionObserver* IntersectionObserver::create(const IntersectionObserverInit& observerInit, IntersectionObserverCallback& callback, ExceptionState& exceptionState)
 {
     Node* root = observerInit.root();
     if (!root) {
-        // TODO(szager): Use Document instead of document element for implicit root. (crbug.com/570538)
         ExecutionContext* context = callback.getExecutionContext();
         DCHECK(context->isDocument());
-        Frame* mainFrame = toDocument(context)->frame()->tree().top();
-        if (mainFrame && mainFrame->isLocalFrame())
-            root = toLocalFrame(mainFrame)->document();
+        root = getRootNode(toDocument(context));
     }
     if (!root) {
         exceptionState.throwDOMException(HierarchyRequestError, "Unable to get root node 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::create(const Vector<Length>& rootMargin, const Vector<float>& thresholds, Document* document, std::unique_ptr<EventCallback> callback)
+{
+    Node* root = getRootNode(document);
+    if (!root)
+        return nullptr;
+
+    IntersectionObserverCallbackImpl* intersectionObserverCallback = new IntersectionObserverCallbackImpl(document, std::move(callback));
+    return new IntersectionObserver(*intersectionObserverCallback, *root, rootMargin, thresholds);
+}
+
 IntersectionObserver::IntersectionObserver(IntersectionObserverCallback& callback, Node& root, const Vector<Length>& rootMargin, const Vector<float>& thresholds)
     : m_callback(&callback)
     , m_root(&root)
     , m_thresholds(thresholds)
     , m_topMargin(Fixed)
     , m_rightMargin(Fixed)
     , m_bottomMargin(Fixed)
     , m_leftMargin(Fixed)
 {
     switch (rootMargin.size()) {
@@ skipping 46 matching lines @@
     if (!m_root) {
         exceptionState.throwDOMException(InvalidStateError, "observe() called on an IntersectionObserver with an invalid root.");
         return;
     }
 
     if (!target || m_root.get() == target)
         return;
 
     if (target->ensureIntersectionObserverData().getObservationFor(*this))
         return;
-
     bool shouldReportRootBounds = false;
     bool isDOMDescendant = false;
     LocalFrame* targetFrame = target->document().frame();
     LocalFrame* rootFrame = m_root->document().frame();
 
     if (target->document() == rootNode()->document()) {
         shouldReportRootBounds = true;
         isDOMDescendant = target->isDescendantOf(rootNode());
     } else if (targetFrame && rootFrame) {
         shouldReportRootBounds = targetFrame->securityContext()->getSecurityOrigin()->canAccess(rootFrame->securityContext()->getSecurityOrigin());
@@ skipping 135 matching lines @@
 unsigned IntersectionObserver::firstThresholdGreaterThan(float ratio) const
 {
     unsigned result = 0;
     while (result < m_thresholds.size() && m_thresholds[result] <= ratio)
         ++result;
     return result;
 }
 
 void IntersectionObserver::deliver()
 {
-
     if (m_entries.isEmpty())
         return;
 
     HeapVector<Member<IntersectionObserverEntry>> entries;
     entries.swap(m_entries);
     m_callback->handleEvent(entries, *this);
 }
 
 DEFINE_TRACE(IntersectionObserver)
 {
     visitor->template registerWeakMembers<IntersectionObserver, &IntersectionObserver::clearWeakMembers>(this);
     visitor->trace(m_callback);
     visitor->trace(m_observations);
     visitor->trace(m_entries);
 }
 
 } // namespace blink