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)

[miu, 2016/11/05 02:47:46]

Did you intend to remove the 3rd argument to this ctor? Otherwise, why are you
ignoring it now?

[xjz, 2016/11/09 02:24:28]

Now keep this argument for original purpose. 

     : m_observer(observer),
       m_target(&target),
-      m_shouldReportRootBounds(shouldReportRootBounds),
+      m_shouldReportRootBounds(true),
       m_lastThresholdIndex(0) {}
 
 void IntersectionObservation::applyRootMargin(LayoutRect& rect) const {
   if (m_shouldReportRootBounds)
     m_observer->applyRootMargin(rect);
 }
 
 void IntersectionObservation::initializeGeometry(
     IntersectionGeometry& geometry) const {
   initializeTargetRect(geometry.targetRect);
@@ skipping 180 matching lines @@
   unsigned newThresholdIndex;
   float newVisibleRatio = 0;
   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;
+    float rootArea = geometry.rootRect.size().width().toFloat() *
+                     geometry.rootRect.size().height().toFloat();
+    newVisibleRatio = intersectionArea / rootArea;
     newThresholdIndex = observer().firstThresholdGreaterThan(newVisibleRatio);
   }
   if (m_lastThresholdIndex != newThresholdIndex) {
     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());
@@ skipping 13 matching lines @@
     target()->ensureIntersectionObserverData().removeObservation(observer());
   m_observer.clear();
 }
 
 DEFINE_TRACE(IntersectionObservation) {
   visitor->trace(m_observer);
   visitor->trace(m_target);
 }
 
 }  // namespace blink