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 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 154 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(

[szager1, 2016/11/16 22:11:22]

I agree with Ojan's point that this should be handled by
LayoutView::mapToVisualRectInAncestorSpace without the need for an
intersectWithRemoteAncestors flag here.

[kenrb, 2016/11/21 19:37:35]

In the most recent PS I have modified mapToVisualRectInAncestorSpace as you
suggested, and removed this method (intersectWithRemoteAncestorsIfNeeded), but
the flag is still necessary.

IntersectionObserver still needs a reference to the local frame root for most of
the things it does with the root, but then it needs to know to call
mapToVisualRectInAncestorSpace with nullptr instead of the local root pointer.
The way I have implemented it now adds a new layout object accessor to
IntersectionObserver for the call to mapToVisualRectInAncestorSpace. If there is
a different way you'd prefer to have it done, then I can change it.

[ojan, 2016/11/23 19:14:00]

Can we always pass nullptr to mapToVisualRectInAncestorSpace if no root was
provided to IntersectionObserver::create? That way we won't need any
special-casing of code for remote frames outside of the couple lines in
mapToVisualRectInAncestorSpace that intersect with
frameView()->remoteViewportIntersection().

With IntersectionObserver, the only case where we need to cross frame boundaries
is when the root is null. We can add an assert to mapToVisualRectInAncestorSpace
that the provided ancestor is in the same Document as the LayoutView to ensure
other code doesn't try to cross frame boundaries to something other than the
top-most frame.

[kenrb, 2016/11/23 20:07:28]

We still need a boolean in the IntersectionObserver constructor though, right?
We need a reference to the local frame root for other reasons (there is no path
to the layout tree, otherwise), and the information that there was originally a
null root pointer passed to create() is lost. I had previously considered
passing a second pointer in the constructor for this purpose, but then realized
that it would always either be null or equal to |root|, which seems like an
over-complicated way of saying 'boolean'. Your suggestion seems to amount to us
changing the name of the boolean to m_intersectWithViewportOnly (or something
similar), and using it also for local cross-frame intersections.

However, does this create a problem for knowing whether or not to apply root
margins? Currently this CL only sets shouldReportRootBounds when intersecting
with the viewport and the main frame is local, which seems to correctly make IO
in an OOPIF process ignore margins from the local frame root. I don't know how
to handle that if we combine those situations.

+    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