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_initialState(InitialState::kHidden) {
+      m_initialState(InitialState::kHidden),
+      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 25 matching lines @@
   m_root = nullptr;
 }
 
 LayoutObject* IntersectionObserver::rootLayoutObject() const {
   Node* node = rootNode();
   if (node->isDocumentNode())
     return LayoutAPIShim::layoutObjectFrom(toDocument(node)->layoutViewItem());
   return toElement(node)->layoutObject();
 }
 
+LayoutObject* IntersectionObserver::rootLayoutObjectForIntersection() const {
+  if (m_intersectWithRemoteAncestors)
+    return nullptr;
+  return rootLayoutObject();
+}
+
 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;
+    if (!m_intersectWithRemoteAncestors)

[ojan, 2016/11/23 22:55:54]

Isn't this always true if target and root are in the same frame?

[kenrb, 2016/11/23 23:23:25]

This is the special case problem I am thinking about. If the target is in the
real root frame (not an OOPIF) then we want to set shouldReportRootBounds to
true, and the observations will take the root margins into account (see
IntersectionObservation::applyRootMargin). For OOPIFs, we are using the local
frame root as rootNode(), which isn't the top-level frame. In that case we don't
want to apply root margins.

+      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 163 matching lines @@
 
 DEFINE_TRACE(IntersectionObserver) {
   visitor->template registerWeakMembers<
       IntersectionObserver, &IntersectionObserver::clearWeakMembers>(this);
   visitor->trace(m_callback);
   visitor->trace(m_observations);
   visitor->trace(m_entries);
 }
 
 }  // namespace blink