Monitor the intersection of video and viewport.

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 186 matching lines @@
     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),
-      m_initialState(InitialState::kHidden) {
+      m_initialState(InitialState::kHidden),
+      m_observeViewportIntersection(thresholds.isEmpty()) {
   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];
@@ skipping 44 matching lines @@
   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()) {
+  if (m_observeViewportIntersection) {

[szager1, 2016/11/16 21:37:55]

Hmm... you're using m_observerViewportIntersection as a kind of hacky
alternative to sub-classing IntersectionObserver.  I think you should just
sub-class IntersectionObserver.  Something like:

class IntersectionObserver {
...
  protected:
    virtual IntersectionObservation* createObservation(Element& target, bool
shouldReportRootBounds) final {
      return new IntersectionObservation(*this, target, shouldReportRootBounds);
    }
}

class ViewportIntersectionObserver : public IntersectionObserver {
  protected:
    IntersectionObservation* createObservation(Element& target, bool) {
      return new ViewportIntersectionObservation(*this, target);
    }
}

void IntersectionObserver::observe(...) {
  ...
  IntersectionObservation* observation = createObservation(*target,
shouldReportRootBounds);
  ...
}

[xjz, 2016/11/16 22:57:15]

Done.

+    shouldReportRootBounds = true;
+  } else if (target->document() == rootNode()->document()) {
     shouldReportRootBounds = true;
     isDOMDescendant = rootNode()->isShadowIncludingInclusiveAncestorOf(target);
   } else if (targetFrame && rootFrame) {
     shouldReportRootBounds =
         targetFrame->securityContext()->getSecurityOrigin()->canAccess(
             rootFrame->securityContext()->getSecurityOrigin());
     isDOMDescendant = (targetFrame->tree().top() == rootFrame);
   }
 
-  IntersectionObservation* observation =
-      new IntersectionObservation(*this, *target, shouldReportRootBounds);
+  IntersectionObservation* observation;
+  if (m_observeViewportIntersection) {
+    observation = new ViewportIntersectionObservation(*this, *target);
+  } else {
+    observation =
+        new IntersectionObservation(*this, *target, shouldReportRootBounds);
+  }
   target->ensureIntersectionObserverData().addObservation(*observation);
   m_observations.add(observation);
 
   if (!isDOMDescendant) {
     m_root->document().addConsoleMessage(
         ConsoleMessage::create(JSMessageSource, WarningMessageLevel,
                                "IntersectionObserver.observe(target): target "
                                "element is not a descendant of root."));
     return;
   }
@@ skipping 153 matching lines @@
 
 DEFINE_TRACE(IntersectionObserver) {
   visitor->template registerWeakMembers<
       IntersectionObserver, &IntersectionObserver::clearWeakMembers>(this);
   visitor->trace(m_callback);
   visitor->trace(m_observations);
   visitor->trace(m_entries);
 }
 
 }  // namespace blink