Intersection Observer support for OOPIF

third_party/WebKit/Source/core/layout/IntersectionGeometry.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/layout/IntersectionGeometry.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/LayoutBox.h"
@@ skipping 91 matching lines @@
   m_intersectionRect = m_targetRect;
   initializeRootRect();
 }
 
 void IntersectionGeometry::initializeTargetRect() {
   m_targetRect =
       LayoutRect(toLayoutBoxModelObject(target())->borderBoundingBox());
 }
 
 void IntersectionGeometry::initializeRootRect() {
-  // TODO(szager): In OOPIF, m_root will be the LayoutView of the
-  // localFrameRoot().  Once viewport intersection support lands,
-  // add a call to mapToVisualRectInAncestorSpace to map the rect up to
-  // top-level frame coordinates.
   if (m_root->isLayoutView()) {
     m_rootRect =
         LayoutRect(toLayoutView(m_root)->frameView()->visibleContentRect());
+    m_root->mapToVisualRectInAncestorSpace(nullptr, m_rootRect);
   } else if (m_root->isBox() && m_root->hasOverflowClip()) {
     m_rootRect = LayoutRect(toLayoutBox(m_root)->contentBoxRect());
   } else {
     m_rootRect =
         LayoutRect(toLayoutBoxModelObject(m_root)->borderBoundingBox());
   }
   applyRootMargin();
 }
 
 void IntersectionGeometry::applyRootMargin() {
   if (m_rootMargin.isEmpty())
     return;
 
   // TODO(szager): Make sure the spec is clear that left/right margins are
   // resolved against width and not height.
   LayoutUnit topMargin = computeMargin(m_rootMargin[0], m_rootRect.height());
   LayoutUnit rightMargin = computeMargin(m_rootMargin[1], m_rootRect.width());
   LayoutUnit bottomMargin = computeMargin(m_rootMargin[2], m_rootRect.height());
   LayoutUnit leftMargin = computeMargin(m_rootMargin[3], m_rootRect.width());
 
   m_rootRect.setX(m_rootRect.x() - leftMargin);
   m_rootRect.setWidth(m_rootRect.width() + leftMargin + rightMargin);
   m_rootRect.setY(m_rootRect.y() - topMargin);
   m_rootRect.setHeight(m_rootRect.height() + topMargin + bottomMargin);
 }
 
 void IntersectionGeometry::clipToRoot() {
   // Map and clip rect into root element coordinates.
   // TODO(szager): the writing mode flipping needs a test.
-  // TODO(szager): Once the OOPIF viewport intersection code lands,
-  // use nullptr for ancestor to map to the top frame.
   LayoutBox* ancestor = toLayoutBox(m_root);
   m_doesIntersect = m_target->mapToVisualRectInAncestorSpace(
-      ancestor, m_intersectionRect, EdgeInclusive);
+      (rootIsImplicit() ? nullptr : ancestor), m_intersectionRect,
+      EdgeInclusive);
   if (ancestor && ancestor->hasOverflowClip())
     m_intersectionRect.move(-ancestor->scrolledContentOffset());
   if (!m_doesIntersect)
     return;
   LayoutRect rootClipRect(m_rootRect);
   if (ancestor)
     ancestor->flipForWritingMode(rootClipRect);
   m_doesIntersect &= m_intersectionRect.inclusiveIntersect(rootClipRect);
 }
 
 void IntersectionGeometry::mapTargetRectToTargetFrameCoordinates() {
   Document& targetDocument = m_target->document();
   LayoutSize scrollPosition =
       LayoutSize(targetDocument.view()->getScrollOffset());
   mapRectUpToDocument(m_targetRect, *m_target, targetDocument);
   m_targetRect.move(-scrollPosition);
 }
 
 void IntersectionGeometry::mapRootRectToRootFrameCoordinates() {
-  Document& rootDocument = m_root->document();
-  if (!rootIsImplicit())
-    mapRectUpToDocument(m_rootRect, *m_root, rootDocument);
-  // TODO(szager): When OOPIF support lands, this scroll offset adjustment
-  // will probably be wrong.
-  LayoutSize scrollPosition =
-      LayoutSize(rootDocument.view()->getScrollOffset());
-  m_rootRect.move(-scrollPosition);
+  m_root->frameView()->mapQuadToAncestorFrameIncludingScrollOffset(
+      m_rootRect, m_root,
+      rootIsImplicit() ? nullptr : m_root->document().layoutView(),
+      UseTransforms | ApplyContainerFlip);
 }
 
 void IntersectionGeometry::mapIntersectionRectToTargetFrameCoordinates() {
   Document& targetDocument = m_target->document();
   if (rootIsImplicit()) {
     LocalFrame* targetFrame = targetDocument.frame();
     Frame* rootFrame = targetFrame->tree().top();
     LayoutSize scrollPosition =
         LayoutSize(targetDocument.view()->getScrollOffset());
     if (targetFrame != rootFrame)
@@ skipping 16 matching lines @@
     mapIntersectionRectToTargetFrameCoordinates();
   else
     m_intersectionRect = LayoutRect();
   // Small optimization: if we're not going to report root bounds, don't bother
   // transforming them to the frame.
   if (shouldReportRootBounds())
     mapRootRectToRootFrameCoordinates();
 }
 
 }  // namespace blink