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"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/PaintLayer.h"
 
 namespace blink {
 
 IntersectionObservation::IntersectionObservation(IntersectionObserver& observer,
                                                  Element& target,
                                                  bool shouldReportRootBounds)
     : m_observer(observer),
       m_target(&target),
       m_shouldReportRootBounds(shouldReportRootBounds),
       m_lastThresholdIndex(0) {}
 
+IntersectionObservation::~IntersectionObservation() {}
+
 void IntersectionObservation::applyRootMargin(LayoutRect& rect) const {
   if (m_shouldReportRootBounds)
     m_observer->applyRootMargin(rect);
 }
 
 void IntersectionObservation::initializeGeometry(
     IntersectionGeometry& geometry) const {
   initializeTargetRect(geometry.targetRect);
   geometry.intersectionRect = geometry.targetRect;
   initializeRootRect(geometry.rootRect);
@@ skipping 213 matching lines @@
   if (m_target)
     target()->ensureIntersectionObserverData().removeObservation(observer());
   m_observer.clear();
 }
 
 DEFINE_TRACE(IntersectionObservation) {
   visitor->trace(m_observer);
   visitor->trace(m_target);
 }
 
+IntersectViewportRatioObservation::IntersectViewportRatioObservation(
+    IntersectionObserver& observer,
+    Element& element)
+    : IntersectionObservation(observer, element, true) {}
+
+IntersectViewportRatioObservation::~IntersectViewportRatioObservation() {}
+
+void IntersectViewportRatioObservation::computeIntersectionObservations(
+    DOMHighResTimeStamp timestamp) {
+  IntersectionGeometry geometry;
+  if (!computeGeometry(geometry))
+    return;
+
+  float newVisibleRatio = 0;
+  if (!geometry.targetRect.isEmpty() && geometry.doesIntersect) {

[miu, 2016/11/14 21:03:33]

This should check that |rootRect| is not empty instead of |targetRect| (to
prevent possible divide-by-zero crashes).

[xjz, 2016/11/15 23:03:39]

Done.

+    float intersectionArea =
+        geometry.intersectionRect.size().width().toFloat() *
+        geometry.intersectionRect.size().height().toFloat();
+    float rootArea = geometry.rootRect.size().width().toFloat() *
+                     geometry.rootRect.size().height().toFloat();
+    newVisibleRatio = intersectionArea / rootArea;
+  }
+  if (newVisibleRatio != m_lastVisibleRatio) {

[miu, 2016/11/14 21:03:33]

A second thought on this: Maybe we should send the ratio, even if it has not
changed? Our control logic wants to know about any changes in position as well
so we don't activate while the video is re-positioning. For example, let's say
the video is fully contained within the viewport and fills 90% of it. If the
video moves up or down (e.g., user scroll or layout), but stays contained within
the viewport, we should not activate remoting until the movement stops.

So, consider making this:

  if (geometry.intersectionRect != m_lastIntersectionRect) {
    ...

Also, thinking aloud: I wonder if the public interface should expose how the
video is moving when the ratio is the same? Perhaps, instead of the ratio, we
should be sending the intersection rect and the root rect? Or, we could send the
relative position and size, computed as:

  float relativeX = geometry.intersectionRect.x().toFloat() /
geometry.rootRect.width().toFloat();
  float relativeY = geometry.intersectionRect.y().toFloat() /
geometry.rootRect.height().toFloat();
  float relativeWidth = geometry.intersectionRect.width().toFloat() /
geometry.rootRect.width().toFloat();
  float relativeHeight = geometry.intersectionRect.height().toFloat() /
geometry.rootRect.height().toFloat();

This would allow us to be more intelligent about the activation decisions in
downstream code, if we find out we need to be. What do you think?

[xjz, 2016/11/15 23:03:39]

Since we don't know the more intelligent logic for now, I changed to report both
rootRect and intersectRect. And did a bunch of renaming accordingly.

+    IntRect snappedRootBounds = pixelSnappedIntRect(geometry.rootRect);
+    IntersectionObserverEntry* newEntry = new IntersectionObserverEntry(
+        timestamp, newVisibleRatio, pixelSnappedIntRect(geometry.targetRect),
+        &snappedRootBounds, pixelSnappedIntRect(geometry.intersectionRect),
+        target());
+    observer().enqueueIntersectionObserverEntry(*newEntry);
+    m_lastVisibleRatio = newVisibleRatio;
+  }
+}
+
 }  // namespace blink