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 151 matching lines @@
   Vector<Length> rootMargin;
   parseRootMargin(observerInit.rootMargin(), rootMargin, exceptionState);
   if (exceptionState.hadException())
     return nullptr;
 
   Vector<float> thresholds;
   parseThresholds(observerInit.threshold(), thresholds, exceptionState);
   if (exceptionState.hadException())
     return nullptr;
 
-  return new IntersectionObserver(callback, *root, rootMargin, thresholds);
+  return new IntersectionObserver(callback, *root, rootMargin, thresholds,
+                                  false);
 }
 
 IntersectionObserver* IntersectionObserver::create(
     const Vector<Length>& rootMargin,
     const Vector<float>& thresholds,
     Document* document,
     std::unique_ptr<EventCallback> callback,
     ExceptionState& exceptionState) {
   Node* root = getRootNode(document);
   if (!root) {
     exceptionState.throwDOMException(
         HierarchyRequestError,
         "Unable to get root node in main frame to track.");
     return nullptr;
   }
 
   IntersectionObserverCallbackImpl* intersectionObserverCallback =
       new IntersectionObserverCallbackImpl(document, std::move(callback));
   return new IntersectionObserver(*intersectionObserverCallback, *root,
-                                  rootMargin, thresholds);
+                                  rootMargin, thresholds, false);
+}
+
+IntersectionObserver* IntersectionObserver::create(
+    const Vector<Length>& rootMargin,
+    Document* document,
+    std::unique_ptr<EventCallback> callback,
+    ExceptionState& exceptionState) {
+  Node* root = getRootNode(document);
+  if (!root) {
+    exceptionState.throwDOMException(
+        HierarchyRequestError,
+        "Unable to get root node in main frame to track.");
+    return nullptr;
+  }
+
+  IntersectionObserverCallbackImpl* intersectionObserverCallback =
+      new IntersectionObserverCallbackImpl(document, std::move(callback));
+  return new IntersectionObserver(*intersectionObserverCallback, *root,
+                                  rootMargin, Vector<float>(), true);
 }
 
 IntersectionObserver::IntersectionObserver(
     IntersectionObserverCallback& callback,
     Node& root,
     const Vector<Length>& rootMargin,
-    const Vector<float>& thresholds)
+    const Vector<float>& thresholds,
+    bool observeViewportIntersection)
     : 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(observeViewportIntersection) {
   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) {
+    shouldReportRootBounds = true;
+  } else if (target->document() == rootNode()->document()) {

[szager1, 2016/11/16 17:53:54]

Please push the logic for determining shouldReportRootBounds out to all callers.
 It's very weird to have logic here that overrides the constructor argument.

Maybe add a static method to IntersectionObserver:

static bool hierarchyAllowsRootBoundsReporting(Node& root, Element& target);

... which contains all of the previous logic for calculating
shouldReportRootBounds.  Then, change all of the callers to:

IntersectionObserver::create(...,
IntersectionObserver::hierarchyAllowsRootBoundsReporting(root, target));

[xjz, 2016/11/16 20:38:59]

Sorry, I didn't quite get your comment "It's very weird to have logic here that
overrides the constructor argument". IIUC, |shouldReportRootBounds| is a
parameter for |IntersectionObservation|, which is created below. And the
parameter is for some optimization. In the case that observing the intersection
with viewport, we always need this info, so we set it true. IMHO, it is totally
fine to put the logic here just before creating the |IntersectionObservation|.
WDYT?

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

[szager1, 2016/11/16 17:53:54]

Why is this 'if' clause necessary?  The value of shouldReportRootBounds should
be accurate in all cases.

[xjz, 2016/11/16 20:38:59]

This 'if' clause here is to create the ViewportIntersectionObservation if
observing the intersection with the viewport. Two difference with the
normal(orginal) IntersectionObservation. 1) No ratio is computed. Therefore
IntersectionObserverEntry::intersectionRatio() is meaningless. 2) No thresholds
is used. Any change on intersection rect will be reported through
IntersectionObserverEntry::rootBounds() and
IntersectionObserverEntry::intersectionRect().

+    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