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 161 matching lines @@
     return toElement(node)->layoutObject();
 }
 
 void IntersectionObserver::observe(Element* target, ExceptionState& exceptionState)
 {
     if (!m_root) {
         exceptionState.throwDOMException(InvalidStateError, "observe() called on an IntersectionObserver with an invalid root.");
         return;
     }
 
+    observe(target);

[szager1, 2016/06/10 21:07:17]

Infinite recursion.

[szager1, 2016/06/10 21:09:23]

Oh never mind, I see what you did here.  I would prefer that you just use an
IgnorableExceptionState:

IgnorableExceptionState exceptionState;
observer->observe(target, exceptionState);

+}
+
+void IntersectionObserver::observe(Element* target)
+{
+    DCHECK(m_root);
+
     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 17 matching lines @@
         rootFrameView->scheduleAnimation();
 }
 
 void IntersectionObserver::unobserve(Element* target, ExceptionState& exceptionState)
 {
     if (!m_root) {
         exceptionState.throwDOMException(InvalidStateError, "unobserve() called on an IntersectionObserver with an invalid root.");
         return;
     }
 
+    unobserve(target);

[szager1, 2016/06/10 21:07:49]

Infinite recursion.

[szager1, 2016/06/10 21:09:23]

Same comment.

+}
+
+void IntersectionObserver::unobserve(Element* target)
+{
+    DCHECK(m_root);
+
     if (!target || !target->intersectionObserverData())
         return;
     // TODO(szager): unobserve callback
     if (IntersectionObservation* observation = target->intersectionObserverData()->getObservationFor(*this))
         observation->disconnect();
 }
 
 void IntersectionObserver::computeIntersectionObservations()
 {
     Document* callbackDocument = toDocument(m_callback->getExecutionContext());
@@ skipping 98 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