Intersection Observer support for OOPIF

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 114 matching lines @@
           "Threshold values must be numbers between 0 and 1");
       break;
     }
   }
 
   std::sort(thresholds.begin(), thresholds.end());
 }
 
 // Returns the root Node of a given Document to use as the IntersectionObserver
 // root when no root is given.
-// TODO(szager): it doesn't support RemoteFrames, see https://crbug.com/615156
 Node* getRootNode(Document* document) {
-  Frame* mainFrame = document->frame()->tree().top();
-  if (mainFrame && mainFrame->isLocalFrame())
-    return toLocalFrame(mainFrame)->document();
+  LocalFrame* rootFrame = document->frame()->localFrameRoot();
+  if (rootFrame)
+    return rootFrame->document();
   return nullptr;
 }
 
 }  // anonymous namespace
 
 IntersectionObserver* IntersectionObserver::create(
     const IntersectionObserverInit& observerInit,
     IntersectionObserverCallback& callback,
     ExceptionState& exceptionState) {
+  bool intersectWithRemoteAncestors = false;
   Node* root = observerInit.root();
   if (!root) {
     ExecutionContext* context = callback.getExecutionContext();
     DCHECK(context->isDocument());
     root = getRootNode(toDocument(context));
+    if (root && (toDocument(context)->frame()->tree().top()->isRemoteFrame() ||
+                 root !=
+                     toLocalFrame(toDocument(context)->frame()->tree().top())
+                         ->document()))
+      intersectWithRemoteAncestors = true;
   }
   if (!root) {
     exceptionState.throwDOMException(
         HierarchyRequestError,
         "Unable to get root node in main frame to track.");
     return nullptr;
   }
 
   Vector<Length> rootMargin;
   parseRootMargin(observerInit.rootMargin(), rootMargin, exceptionState);
   if (exceptionState.hadException())
     return nullptr;
 
   Vector<float> thresholds;
   parseThresholds(observerInit.threshold(), thresholds, exceptionState);
   if (exceptionState.hadException())
     return nullptr;
 
-  return new IntersectionObserver(callback, *root, rootMargin, thresholds);
+  return new IntersectionObserver(callback, *root, rootMargin, thresholds,
+                                  intersectWithRemoteAncestors);
 }
 
 IntersectionObserver* IntersectionObserver::create(
     const Vector<Length>& rootMargin,
     const Vector<float>& thresholds,
     Document* document,
     std::unique_ptr<EventCallback> callback,
     ExceptionState& exceptionState) {
   Node* root = getRootNode(document);
+  bool intersectWithRemoteAncestors = false;
+  if (root &&
+      (document->frame()->tree().top()->isRemoteFrame() ||
+       root != toLocalFrame(document->frame()->tree().top())->document()))
+    intersectWithRemoteAncestors = true;
   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);
+                                  rootMargin, thresholds,
+                                  intersectWithRemoteAncestors);
 }
 
 IntersectionObserver::IntersectionObserver(
     IntersectionObserverCallback& callback,
     Node& root,
     const Vector<Length>& rootMargin,
-    const Vector<float>& thresholds)
+    const Vector<float>& thresholds,
+    bool intersectWithRemoteAncestors)
     : m_callback(&callback),
       m_root(&root),
       m_thresholds(thresholds),
       m_topMargin(Fixed),
       m_rightMargin(Fixed),
       m_bottomMargin(Fixed),
-      m_leftMargin(Fixed) {
+      m_leftMargin(Fixed),
+      m_intersectWithRemoteAncestors(intersectWithRemoteAncestors) {
   switch (rootMargin.size()) {
     case 0:
       break;
     case 1:
       m_topMargin = m_rightMargin = m_bottomMargin = m_leftMargin =
           rootMargin[0];
       break;
     case 2:
       m_topMargin = m_bottomMargin = rootMargin[0];
       m_rightMargin = m_leftMargin = rootMargin[1];
@@ skipping 45 matching lines @@
     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;
+    if (!m_intersectWithRemoteAncestors)
+      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);
@@ 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);
 }
 
+void IntersectionObserver::intersectWithRemoteAncestorsIfNeeded(
+    LayoutRect& rect) {
+  if (m_intersectWithRemoteAncestors) {
+    Document* root = toDocument(rootNode());
+    if (root->view()) {
+      LayoutRect viewportIntersectionRect(
+          root->view()->remoteViewportIntersection());
+      rect.intersect(viewportIntersectionRect);
+    }
+  }
+}
+
 DEFINE_TRACE(IntersectionObserver) {
   visitor->template registerWeakMembers<
       IntersectionObserver, &IntersectionObserver::clearWeakMembers>(this);
   visitor->trace(m_callback);
   visitor->trace(m_observations);
   visitor->trace(m_entries);
 }
 
 }  // namespace blink