Monitor the intersection of video and viewport.

third_party/WebKit/Source/core/dom/IntersectionObservation.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/IntersectionObservation.h"
 
 #include "core/dom/ElementRareData.h"
 #include "core/dom/IntersectionObserver.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 192 matching lines @@
   //     only two states are recognized:
   //     - 0 means not intersecting.
   //     - 1 means intersecting.
   //     No other threshold crossings are possible.
   //   - Otherwise:
   //     - If root and target do not intersect, the threshold index is 0.
   //     - If root and target intersect but the intersection has zero-area
   //       (i.e., they have a coincident edge or corner), we consider the
   //       intersection to have "crossed" a zero threshold, but not crossed
   //       any non-zero threshold.
+  // When observer is observing the element/viewport ratio, ignore thresholds
+  // and report any changes on ratio.
   unsigned newThresholdIndex;
   float newVisibleRatio = 0;
+  bool isObservingRatio = m_observer->isObservingElementViewportRatio();

[miu, 2016/11/09 22:02:08]

naming/semantics: IMHO, this shouldn't semantically mean "the observer is
observing the viewport ratio." Instead, the behavior we want is "the observer
wants continuous measurement updates, not just threshold change updates." So, I
think you should delete this LOC, and just make a small change to the
if-statement near the bottom of this method (see later comments).

[xjz, 2016/11/11 01:07:29]

Not needed. Added a subclass to observe element/viewport ratio changes.

   if (geometry.targetRect.isEmpty()) {
     newThresholdIndex = geometry.doesIntersect ? 1 : 0;
   } else if (!geometry.doesIntersect) {
     newThresholdIndex = 0;
   } else {
     float intersectionArea =
         geometry.intersectionRect.size().width().toFloat() *
         geometry.intersectionRect.size().height().toFloat();
-    float targetArea = geometry.targetRect.size().width().toFloat() *
-                       geometry.targetRect.size().height().toFloat();
-    newVisibleRatio = intersectionArea / targetArea;
-    newThresholdIndex = observer().firstThresholdGreaterThan(newVisibleRatio);
+    if (isObservingRatio) {
+      float rootArea = geometry.rootRect.size().width().toFloat() *

[miu, 2016/11/09 22:02:07]

Doesn't seem like the math should be different. Won't |geometry.targetRect| be
equal to |geometry.rootRect| for our use case?

[xjz, 2016/11/11 01:07:29]

They are different. The targetRect is the element that is observed (video
element in our case), not the viewport.

+                       geometry.rootRect.size().height().toFloat();
+      newVisibleRatio = intersectionArea / rootArea;
+    } else {
+      float targetArea = geometry.targetRect.size().width().toFloat() *
+                         geometry.targetRect.size().height().toFloat();
+      newVisibleRatio = intersectionArea / targetArea;
+      newThresholdIndex = observer().firstThresholdGreaterThan(newVisibleRatio);
+    }
   }
-  if (m_lastThresholdIndex != newThresholdIndex) {
+  bool shouldReportChange =
+      (isObservingRatio && m_lastVisibleRatio != newVisibleRatio) ||
+      (!isObservingRatio && m_lastThresholdIndex != newThresholdIndex);
+  if (shouldReportChange) {

[miu, 2016/11/09 22:02:07]

IMHO, this change should be:

  if (m_lastThresholdIndex != newThresholdIndex ||
      m_observer->isObservingContinuousChanges()) {

[xjz, 2016/11/11 01:07:29]

I think we only want to report if the ratio is changed, do we?

     IntRect snappedRootBounds = pixelSnappedIntRect(geometry.rootRect);
     IntRect* rootBoundsPointer =
         m_shouldReportRootBounds ? &snappedRootBounds : nullptr;
     IntersectionObserverEntry* newEntry = new IntersectionObserverEntry(
         timestamp, newVisibleRatio, pixelSnappedIntRect(geometry.targetRect),
         rootBoundsPointer, pixelSnappedIntRect(geometry.intersectionRect),
         target());
     observer().enqueueIntersectionObserverEntry(*newEntry);
-    setLastThresholdIndex(newThresholdIndex);
+    if (isObservingRatio)
+      m_lastVisibleRatio = newVisibleRatio;
+    else
+      setLastThresholdIndex(newThresholdIndex);
   }
 }
 
 void IntersectionObservation::disconnect() {
   IntersectionObserver* observer = m_observer;
   clearRootAndRemoveFromTarget();
   observer->removeObservation(*this);
 }
 
 void IntersectionObservation::clearRootAndRemoveFromTarget() {
   if (m_target)
     target()->ensureIntersectionObserverData().removeObservation(observer());
   m_observer.clear();
 }
 
 DEFINE_TRACE(IntersectionObservation) {
   visitor->trace(m_observer);
   visitor->trace(m_target);
 }
 
 }  // namespace blink