Detect change on the intersection of video and viewport.

third_party/WebKit/Source/core/dom/IntersectionObserver.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/IntersectionObserver.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/css/parser/CSSParserTokenRange.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "core/dom/Element.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/IntersectionObserverCallback.h"
 #include "core/dom/IntersectionObserverController.h"
 #include "core/dom/IntersectionObserverEntry.h"
 #include "core/dom/IntersectionObserverInit.h"
 #include "core/dom/NodeIntersectionObserverData.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/inspector/ConsoleMessage.h"
-#include "core/layout/api/LayoutAPIShim.h"
-#include "core/layout/api/LayoutViewItem.h"
 #include "core/timing/DOMWindowPerformance.h"
 #include "core/timing/Performance.h"
 #include "platform/Timer.h"
 #include <algorithm>
 
 namespace blink {
 
 namespace {
 
 // Internal implementation of IntersectionObserverCallback when using
@@ skipping 201 matching lines @@
 }
 
 void IntersectionObserver::clearWeakMembers(Visitor* visitor) {
   if (ThreadHeap::isHeapObjectAlive(m_root))
     return;
   IgnorableExceptionState exceptionState;
   disconnect(exceptionState);
   m_root = nullptr;
 }
 
-LayoutObject* IntersectionObserver::rootLayoutObject() const {
-  Node* node = rootNode();
-  if (node->isDocumentNode())
-    return LayoutAPIShim::layoutObjectFrom(toDocument(node)->layoutViewItem());
-  return toElement(node)->layoutObject();
-}
-
 void IntersectionObserver::observe(Element* target,
                                    ExceptionState& exceptionState) {
   if (!m_root) {
     exceptionState.throwDOMException(
         InvalidStateError,
         "observe() called on an IntersectionObserver with an invalid root.");
     return;
   }
 
   if (!target || m_root.get() == target)
     return;
 
   if (target->ensureIntersectionObserverData().getObservationFor(*this))
     return;
   bool shouldReportRootBounds = false;
   bool isDOMDescendant = false;
   LocalFrame* targetFrame = target->document().frame();
   LocalFrame* rootFrame = m_root->document().frame();
 
   if (target->document() == rootNode()->document()) {
     shouldReportRootBounds = true;
     isDOMDescendant = rootNode()->isShadowIncludingInclusiveAncestorOf(target);
   } else if (targetFrame && rootFrame) {
     shouldReportRootBounds =
         targetFrame->securityContext()->getSecurityOrigin()->canAccess(
             rootFrame->securityContext()->getSecurityOrigin());
     isDOMDescendant = (targetFrame->tree().top() == rootFrame);
   }
 
-  IntersectionObservation* observation =
-      new IntersectionObservation(*this, *target, shouldReportRootBounds);
+  IntersectionObservation* observation = new IntersectionObservation(
+      *this, *target,
+      shouldReportRootBounds
+          ? IntersectionGeometry::ReportRootBounds::kShouldReportRootBounds
+          : IntersectionGeometry::ReportRootBounds::kShouldNotReportRootBounds);
   target->ensureIntersectionObserverData().addObservation(*observation);
   m_observations.add(observation);
 
   if (!isDOMDescendant) {
     m_root->document().addConsoleMessage(
         ConsoleMessage::create(JSMessageSource, WarningMessageLevel,
                                "IntersectionObserver.observe(target): target "
                                "element is not a descendant of root."));
     return;
   }
@@ skipping 105 matching lines @@
 }
 
 void IntersectionObserver::enqueueIntersectionObserverEntry(
     IntersectionObserverEntry& entry) {
   m_entries.append(&entry);
   toDocument(m_callback->getExecutionContext())
       ->ensureIntersectionObserverController()
       .scheduleIntersectionObserverForDelivery(*this);
 }
 
-static LayoutUnit computeMargin(const Length& length,
-                                LayoutUnit referenceLength) {
-  if (length.type() == Percent)
-    return LayoutUnit(
-        static_cast<int>(referenceLength.toFloat() * length.percent() / 100.0));
-  DCHECK_EQ(length.type(), Fixed);
-  return LayoutUnit(length.intValue());
-}
-
-void IntersectionObserver::applyRootMargin(LayoutRect& rect) const {
-  // TODO(szager): Make sure the spec is clear that left/right margins are
-  // resolved against width and not height.
-  LayoutUnit topMargin = computeMargin(m_topMargin, rect.height());
-  LayoutUnit rightMargin = computeMargin(m_rightMargin, rect.width());
-  LayoutUnit bottomMargin = computeMargin(m_bottomMargin, rect.height());
-  LayoutUnit leftMargin = computeMargin(m_leftMargin, rect.width());
-
-  rect.setX(rect.x() - leftMargin);
-  rect.setWidth(rect.width() + leftMargin + rightMargin);
-  rect.setY(rect.y() - topMargin);
-  rect.setHeight(rect.height() + topMargin + bottomMargin);
-}
-
 unsigned IntersectionObserver::firstThresholdGreaterThan(float ratio) const {
   unsigned result = 0;
   while (result < m_thresholds.size() && m_thresholds[result] <= ratio)
     ++result;
   return result;
 }
 
 void IntersectionObserver::deliver() {
   if (m_entries.isEmpty())
     return;
 
   HeapVector<Member<IntersectionObserverEntry>> entries;
   entries.swap(m_entries);
   m_callback->handleEvent(entries, *this);
 }
 
 DEFINE_TRACE(IntersectionObserver) {
   visitor->template registerWeakMembers<
       IntersectionObserver, &IntersectionObserver::clearWeakMembers>(this);
   visitor->trace(m_callback);
   visitor->trace(m_observations);
   visitor->trace(m_entries);
 }
 
 }  // namespace blink