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);
 }
 
+ViewportIntersectionObservation::ViewportIntersectionObservation(
+    IntersectionObserver& observer,
+    Element& element)
+    : IntersectionObservation(observer, element, true),
+      m_lastIntersectRect(std::numeric_limits<float>::min(),
+                          std::numeric_limits<float>::min(),
+                          std::numeric_limits<float>::min(),
+                          std::numeric_limits<float>::min()) {}
+
+ViewportIntersectionObservation::~ViewportIntersectionObservation() {}
+
+void ViewportIntersectionObservation::computeIntersectionObservations(
+    DOMHighResTimeStamp timestamp) {
+  IntersectionGeometry geometry;
+  if (!computeGeometry(geometry))
+    return;
+
+  float newVisibleRatio = 0;

[miu, 2016/11/15 23:29:26]

Please remove |newVisibleRatio| and move the ratio computation to
remoting_controller.cc where it is needed.

[xjz, 2016/11/16 01:06:45]

Done.

+  LayoutRect newIntersectRect;
+  if (!geometry.rootRect.isEmpty() && geometry.doesIntersect) {
+    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;
+    newIntersectRect = geometry.intersectionRect;
+  }
+  if (newIntersectRect != m_lastIntersectRect) {
+    IntRect snappedRootBounds = pixelSnappedIntRect(geometry.rootRect);
+    IntersectionObserverEntry* newEntry = new IntersectionObserverEntry(
+        timestamp, newVisibleRatio, pixelSnappedIntRect(geometry.targetRect),
+        &snappedRootBounds, pixelSnappedIntRect(geometry.intersectionRect),
+        target());
+    observer().enqueueIntersectionObserverEntry(*newEntry);
+    m_lastIntersectRect = newIntersectRect;
+  }
+}
+
 }  // namespace blink