Monitor 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"
@@ skipping 170 matching lines @@
   Node* root = getRootNode(document);
   if (!root) {
     exceptionState.throwDOMException(
         HierarchyRequestError,
         "Unable to get root node in main frame to track.");
     return nullptr;
   }
 
   IntersectionObserverCallbackImpl* intersectionObserverCallback =
       new IntersectionObserverCallbackImpl(document, std::move(callback));
-  return new IntersectionObserver(*intersectionObserverCallback, *root,
-                                  rootMargin, thresholds);
+  if (thresholds.isEmpty()) {
+    return new ViewportIntersectionObserver(*intersectionObserverCallback,
+                                            *root, rootMargin);
+  } else {
+    return new IntersectionObserver(*intersectionObserverCallback, *root,
+                                    rootMargin, thresholds);
+  }
 }
 
 IntersectionObserver::IntersectionObserver(
     IntersectionObserverCallback& callback,
     Node& root,
     const Vector<Length>& rootMargin,
     const Vector<float>& thresholds)
     : m_callback(&callback),
       m_root(&root),
       m_thresholds(thresholds),
@@ skipping 25 matching lines @@
       m_leftMargin = rootMargin[3];
       break;
     default:
       NOTREACHED();
       break;
   }
   root.document().ensureIntersectionObserverController().addTrackedObserver(
       *this);
 }
 
+IntersectionObserver::~IntersectionObserver() {}
+
 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();
@@ skipping 25 matching lines @@
     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);
+      createObservation(*target, shouldReportRootBounds);
   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 144 matching lines @@
 
 void IntersectionObserver::deliver() {
   if (m_entries.isEmpty())
     return;
 
   HeapVector<Member<IntersectionObserverEntry>> entries;
   entries.swap(m_entries);
   m_callback->handleEvent(entries, *this);
 }
 
+IntersectionObservation* IntersectionObserver::createObservation(
+    Element& target,
+    bool shouldReportRootBounds) {
+  return new IntersectionObservation(*this, target, shouldReportRootBounds);
+}
+
 DEFINE_TRACE(IntersectionObserver) {
   visitor->template registerWeakMembers<
       IntersectionObserver, &IntersectionObserver::clearWeakMembers>(this);
   visitor->trace(m_callback);
   visitor->trace(m_observations);
   visitor->trace(m_entries);
 }
 
+ViewportIntersectionObserver::ViewportIntersectionObserver(
+    IntersectionObserverCallback& callback,
+    Node& node,
+    const Vector<Length>& rootMargin)
+    : IntersectionObserver(callback, node, rootMargin, Vector<float>()) {}
+
+ViewportIntersectionObserver::~ViewportIntersectionObserver() {}
+
+IntersectionObservation* ViewportIntersectionObserver::createObservation(
+    Element& target,
+    bool) {
+  return new ViewportIntersectionObservation(*this, target);
+}
+
 }  // namespace blink