Monitor the intersection of video and viewport.

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

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
index 32ef04c78978b5f0856a4812c1ff8499585d1e5d..f7653c7b843cf4e6bcab817fae277aa8a5a5e020 100644
--- a/third_party/WebKit/Source/core/dom/IntersectionObserver.cpp
+++ b/third_party/WebKit/Source/core/dom/IntersectionObserver.cpp
@@ -169,7 +169,8 @@ IntersectionObserver* IntersectionObserver::create(
   if (exceptionState.hadException())
     return nullptr;
 
-  return new IntersectionObserver(callback, *root, rootMargin, thresholds);
+  return new IntersectionObserver(callback, *root, rootMargin, thresholds,
+                                  false);
 }
 
 IntersectionObserver* IntersectionObserver::create(
@@ -189,14 +190,34 @@ IntersectionObserver* IntersectionObserver::create(
   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),
@@ -204,7 +225,8 @@ IntersectionObserver::IntersectionObserver(
       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;
@@ -269,7 +291,9 @@ void IntersectionObserver::observe(Element* target,
   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) {
@@ -279,8 +303,13 @@ void IntersectionObserver::observe(Element* target,
     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);