Add support for flattening in GeometryMapper.

third_party/WebKit/Source/core/layout/VisualRectMappingTest.cpp

 // Copyright 2015 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/LayoutTestHelper.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/PaintInvalidationState.h"
 #include "core/paint/PaintLayer.h"
+#include "core/paint/PaintPropertyTreePrinter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
 class VisualRectMappingTest : public RenderingTest {
  public:
   VisualRectMappingTest()
       : RenderingTest(SingleChildLocalFrameClient::create()) {}
 
  protected:
   LayoutView& layoutView() const { return *document().layoutView(); }
 
   void checkPaintInvalidationVisualRect(const LayoutObject& object) {
     LayoutRect rect = object.localVisualRect();
     if (object.isBox())
       toLayoutBox(object).flipForWritingMode(rect);
     const LayoutBoxModelObject& paintInvalidationContainer =
         object.containerForPaintInvalidation();
-    object.mapToVisualRectInAncestorSpace(&paintInvalidationContainer, rect);
-    if (rect.isEmpty() && object.visualRect().isEmpty())
+
+    checkVisualRect(object, paintInvalidationContainer, rect,
+                    object.visualRect(), true);
+  }
+
+  void checkVisualRect(const LayoutObject& object,
+                       const LayoutBoxModelObject& ancestor,
+                       const LayoutRect& localRect,
+                       const LayoutRect& expectedVisualRect,
+                       bool adjustForBacking = false) {
+    LayoutRect slowMapRect = localRect;
+    object.mapToVisualRectInAncestorSpace(&ancestor, slowMapRect);
+    if (slowMapRect.isEmpty() && object.visualRect().isEmpty())
       return;
+
+    FloatRect geometryMapperRect(localRect);
+    if (object.paintProperties()) {
+      geometryMapperRect.moveBy(FloatPoint(object.paintOffset()));
+      document().view()->geometryMapper().sourceToDestinationVisualRect(
+          *object.paintProperties()->localBorderBoxProperties(),
+          *ancestor.paintProperties()->contentsProperties(),
+          geometryMapperRect);
+      geometryMapperRect.moveBy(-FloatPoint(ancestor.paintOffset()));
+    }
+
     // The following condition can be false if paintInvalidationContainer is
     // a LayoutView and compositing is not enabled.
-    if (paintInvalidationContainer.isPaintInvalidationContainer()) {
-      PaintLayer::mapRectInPaintInvalidationContainerToBacking(
-          paintInvalidationContainer, rect);
+    if (adjustForBacking && ancestor.isPaintInvalidationContainer()) {
+      PaintLayer::mapRectInPaintInvalidationContainerToBacking(ancestor,
+                                                               slowMapRect);
+      LayoutRect temp(geometryMapperRect);
+      PaintLayer::mapRectInPaintInvalidationContainerToBacking(ancestor, temp);
+      geometryMapperRect = FloatRect(temp);
     }
-    EXPECT_EQ(enclosingIntRect(rect), enclosingIntRect(object.visualRect()));
+    EXPECT_TRUE(enclosingIntRect(slowMapRect)
+                    .contains(enclosingIntRect(expectedVisualRect)));
+
+    if (object.paintProperties()) {
+      EXPECT_EQ(enclosingIntRect(expectedVisualRect),
+                enclosingIntRect(geometryMapperRect));
+    }
   }
 };
 
 TEST_F(VisualRectMappingTest, LayoutText) {
   setBodyInnerHTML(
       "<style>body { margin: 0; }</style>"
       "<div id='container' style='overflow: scroll; width: 50px; height: 50px'>"
       "  <span><img style='width: 20px; height: 100px'></span>"
       "  text text text text text text text"
       "</div>");
@@ skipping 187 matching lines @@
   // TODO(wkorman): The calls to flipForWritingMode() here and in other test
   // cases below are necessary because mapToVisualRectInAncestorSpace()
   // currently expects the input rect to be in "physical coordinates" (*not*
   // "physical coordinates with flipped block-flow direction"), see
   // LayoutBoxModelObject.h.
   target->flipForWritingMode(rect);
   EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(target, rect));
   // This rect is in physical coordinates of target.
   EXPECT_EQ(LayoutRect(0, 0, 140, 70), rect);
 
-  rect = localVisualRect;
-  target->flipForWritingMode(rect);
-  EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(&layoutView(), rect));
-  EXPECT_EQ(LayoutRect(222, 111, 140, 70), rect);
-  EXPECT_EQ(rect, target->visualRect());
+  checkPaintInvalidationVisualRect(*target);
+  EXPECT_EQ(LayoutRect(222, 111, 140, 70), target->visualRect());
 }
 
 TEST_F(VisualRectMappingTest, ContainerFlippedWritingMode) {
   setBodyInnerHTML(
       "<div id='container' style='writing-mode: vertical-rl;"
       "    position: absolute; top: 111px; left: 222px'>"
       "  <div id='target' style='box-shadow: 40px 20px black; width: 100px;"
       "      height: 90px'></div>"
       "  <div style='width: 100px; height: 100px'></div>"
       "</div>");
@@ skipping 12 matching lines @@
   // This rect is in physical coordinates of target.
   EXPECT_EQ(LayoutRect(0, 0, 140, 110), rect);
 
   LayoutBlock* container =
       toLayoutBlock(getLayoutObjectByElementId("container"));
   rect = targetLocalVisualRect;
   target->flipForWritingMode(rect);
   EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(container, rect));
   // 100 is the physical x location of target in container.
   EXPECT_EQ(LayoutRect(100, 0, 140, 110), rect);
+
   rect = targetLocalVisualRect;
   target->flipForWritingMode(rect);
-  EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(&layoutView(), rect));
-  EXPECT_EQ(LayoutRect(322, 111, 140, 110), rect);
-  EXPECT_EQ(rect, target->visualRect());
+  checkPaintInvalidationVisualRect(*target);
+  EXPECT_EQ(LayoutRect(322, 111, 140, 110), target->visualRect());
 
   LayoutRect containerLocalVisualRect = container->localVisualRect();
   EXPECT_EQ(LayoutRect(0, 0, 200, 100), containerLocalVisualRect);
   rect = containerLocalVisualRect;
   container->flipForWritingMode(rect);
   EXPECT_TRUE(container->mapToVisualRectInAncestorSpace(container, rect));
   EXPECT_EQ(LayoutRect(0, 0, 200, 100), rect);
   rect = containerLocalVisualRect;
   container->flipForWritingMode(rect);
   EXPECT_TRUE(container->mapToVisualRectInAncestorSpace(&layoutView(), rect));
@@ skipping 29 matching lines @@
 
   rect = targetLocalVisualRect;
   EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(container, rect));
   rect.move(-container->scrolledContentOffset());
   // 2 = target_x(0) + container_border_left(10) - scroll_left(8)
   // 3 = target_y(0) + container_border_top(10) - scroll_top(7)
   // Rect is not clipped by container's overflow clip because of
   // overflow:scroll.
   EXPECT_EQ(LayoutRect(2, 3, 140, 110), rect);
 
-  rect = targetLocalVisualRect;
-  EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(&layoutView(), rect));
+  checkPaintInvalidationVisualRect(*target);
   // (2, 3, 140, 100) is first clipped by container's overflow clip, to
   // (10, 10, 50, 80), then is by added container's offset in LayoutView
   // (111, 222).
-  EXPECT_EQ(LayoutRect(232, 121, 50, 80), rect);
-  EXPECT_EQ(rect, target->visualRect());
+  EXPECT_EQ(LayoutRect(232, 121, 50, 80), target->visualRect());
 
   LayoutRect containerLocalVisualRect = container->localVisualRect();
   // Because container has overflow clip, its visual overflow doesn't include
   // overflow from children.
   // 70 = width(50) + border_left_width(10) + border_right_width(10)
   // 100 = height(80) + border_top_width(10) + border_bottom_width(10)
   EXPECT_EQ(LayoutRect(0, 0, 70, 100), containerLocalVisualRect);
   rect = containerLocalVisualRect;
   EXPECT_TRUE(container->mapToVisualRectInAncestorSpace(container, rect));
   // Container should not apply overflow clip on its own overflow rect.
   EXPECT_EQ(LayoutRect(0, 0, 70, 100), rect);
 
-  rect = containerLocalVisualRect;
-  EXPECT_TRUE(container->mapToVisualRectInAncestorSpace(&layoutView(), rect));
-  EXPECT_EQ(LayoutRect(222, 111, 70, 100), rect);
-  EXPECT_EQ(rect, container->visualRect());
+  checkPaintInvalidationVisualRect(*container);
+  EXPECT_EQ(LayoutRect(222, 111, 70, 100), container->visualRect());
 }
 
 TEST_F(VisualRectMappingTest, ContainerFlippedWritingModeAndOverflowScroll) {
   setBodyInnerHTML(
       "<div id='container' style='writing-mode: vertical-rl;"
       "    position: absolute; top: 111px; left: 222px; border: solid red;"
       "    border-width: 10px 20px 30px 40px; overflow: scroll; width: 50px;"
       "    height: 80px'>"
       "  <div id='target' style='box-shadow: 40px 20px black; width: 100px;"
       "      height: 90px'></div>"
@@ skipping 28 matching lines @@
 
   rect = targetLocalVisualRect;
   target->flipForWritingMode(rect);
   EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(container, rect));
   rect.move(-container->scrolledContentOffset());
   // -2 = target_physical_x(100) + container_border_left(40) - scroll_left(142)
   // 3 = target_y(0) + container_border_top(10) - scroll_top(7)
   // Rect is clipped by container's overflow clip because of overflow:scroll.
   EXPECT_EQ(LayoutRect(-2, 3, 140, 110), rect);
 
-  rect = targetLocalVisualRect;
-  target->flipForWritingMode(rect);
-  EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(&layoutView(), rect));
+  checkPaintInvalidationVisualRect(*target);
   // (-2, 3, 140, 100) is first clipped by container's overflow clip, to
   // (40, 10, 50, 80), then is added by container's offset in LayoutView
   // (111, 222).
   // TODO(crbug.com/600039): rect.x() should be 262 (left + border-left), but is
   // offset
   // by extra horizontal border-widths because of layout error.
-  EXPECT_EQ(LayoutRect(322, 121, 50, 80), rect);
-  EXPECT_EQ(rect, target->visualRect());
+  EXPECT_EQ(LayoutRect(322, 121, 50, 80), target->visualRect());
 
   LayoutRect containerLocalVisualRect = container->localVisualRect();
   // Because container has overflow clip, its visual overflow doesn't include
   // overflow from children.
   // 110 = width(50) + border_left_width(40) + border_right_width(20)
   // 120 = height(80) + border_top_width(10) + border_bottom_width(30)
   EXPECT_EQ(LayoutRect(0, 0, 110, 120), containerLocalVisualRect);
 
   rect = containerLocalVisualRect;
   container->flipForWritingMode(rect);
   EXPECT_TRUE(container->mapToVisualRectInAncestorSpace(container, rect));
   EXPECT_EQ(LayoutRect(0, 0, 110, 120), rect);
 
-  rect = containerLocalVisualRect;
-  container->flipForWritingMode(rect);
-  EXPECT_TRUE(container->mapToVisualRectInAncestorSpace(&layoutView(), rect));
   // TODO(crbug.com/600039): rect.x() should be 222 (left), but is offset by
   // extra horizontal
   // border-widths because of layout error.
-  EXPECT_EQ(LayoutRect(282, 111, 110, 120), rect);
-  EXPECT_EQ(rect, container->visualRect());
+  checkPaintInvalidationVisualRect(*container);
+  EXPECT_EQ(LayoutRect(282, 111, 110, 120), container->visualRect());
 }
 
 TEST_F(VisualRectMappingTest, ContainerOverflowHidden) {
   setBodyInnerHTML(
       "<div id='container' style='position: absolute; top: 111px; left: 222px;"
       "    border: 10px solid red; overflow: hidden; width: 50px;"
       "    height: 80px;'>"
       "  <div id='target' style='box-shadow: 40px 20px black; width: 100px;"
       "      height: 90px'></div>"
       "</div>");
 
   LayoutBlock* container =
       toLayoutBlock(getLayoutObjectByElementId("container"));
   EXPECT_EQ(LayoutUnit(), container->scrollTop());
   EXPECT_EQ(LayoutUnit(), container->scrollLeft());
   container->setScrollTop(LayoutUnit(27));
   container->setScrollLeft(LayoutUnit(28));
   document().view()->updateAllLifecyclePhases();
 
   LayoutBlock* target = toLayoutBlock(getLayoutObjectByElementId("target"));
   LayoutRect targetLocalVisualRect = target->localVisualRect();
   // 140 = width(100) + box_shadow_offset_x(40)
   // 110 = height(90) + box_shadow_offset_y(20)
   EXPECT_EQ(LayoutRect(0, 0, 140, 110), targetLocalVisualRect);
   LayoutRect rect = targetLocalVisualRect;
   EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(target, rect));
   EXPECT_EQ(LayoutRect(0, 0, 140, 110), rect);
 
   rect = targetLocalVisualRect;
-  EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(container, rect));
   // Rect is not clipped by container's overflow clip.
-  EXPECT_EQ(LayoutRect(10, 10, 140, 110), rect);
+  checkVisualRect(*target, *container, rect, LayoutRect(10, 10, 140, 110));
 }
 
 TEST_F(VisualRectMappingTest, ContainerFlippedWritingModeAndOverflowHidden) {
   setBodyInnerHTML(
       "<div id='container' style='writing-mode: vertical-rl; "
       "    position: absolute; top: 111px; left: 222px; border: solid red; "
       "    border-width: 10px 20px 30px 40px; overflow: hidden; width: 50px; "
       "    height: 80px'>"
       "  <div id='target' style='box-shadow: 40px 20px black; width: 100px; "
       "      height: 90px'></div>"
@@ skipping 20 matching lines @@
   EXPECT_EQ(LayoutRect(-40, 0, 140, 110), targetLocalVisualRect);
 
   LayoutRect rect = targetLocalVisualRect;
   target->flipForWritingMode(rect);
   EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(target, rect));
   // This rect is in physical coordinates of target.
   EXPECT_EQ(LayoutRect(0, 0, 140, 110), rect);
 
   rect = targetLocalVisualRect;
   target->flipForWritingMode(rect);
+  // 58 = target_physical_x(100) + container_border_left(40) - scroll_left(58)
+  checkVisualRect(*target, *container, rect, LayoutRect(-10, 10, 140, 110));
   EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(container, rect));
-  // 58 = target_physical_x(100) + container_border_left(40) - scroll_left(58)
-  EXPECT_EQ(LayoutRect(-10, 10, 140, 110), rect);
 }
 
 TEST_F(VisualRectMappingTest, ContainerAndTargetDifferentFlippedWritingMode) {
   setBodyInnerHTML(
       "<div id='container' style='writing-mode: vertical-rl;"
       "    position: absolute; top: 111px; left: 222px; border: solid red;"
       "    border-width: 10px 20px 30px 40px; overflow: scroll; width: 50px;"
       "    height: 80px'>"
       "  <div id='target' style='writing-mode: vertical-lr; width: 100px;"
       "      height: 90px; box-shadow: 40px 20px black'></div>"
@@ skipping 65 matching lines @@
   EXPECT_TRUE(normalFlow->mapToVisualRectInAncestorSpace(scroller, rect));
   EXPECT_EQ(LayoutRect(0, 0, 2000, 2000), rect);
   EXPECT_EQ(rect, normalFlow->visualRect());
 
   LayoutBlock* stackingContext =
       toLayoutBlock(getLayoutObjectByElementId("stacking-context"));
   LayoutBlock* absolute = toLayoutBlock(getLayoutObjectByElementId("absolute"));
   EXPECT_EQ(stackingContext, &absolute->containerForPaintInvalidation());
   EXPECT_EQ(stackingContext, absolute->container());
 
-  LayoutRect absoluteVisualRect = absolute->localVisualRect();
-  EXPECT_EQ(LayoutRect(0, 0, 50, 50), absoluteVisualRect);
-  rect = absoluteVisualRect;
-  EXPECT_TRUE(absolute->mapToVisualRectInAncestorSpace(stackingContext, rect));
-  EXPECT_EQ(LayoutRect(222, 111, 50, 50), rect);
-  EXPECT_EQ(rect, absolute->visualRect());
+  EXPECT_EQ(LayoutRect(0, 0, 50, 50), absolute->localVisualRect());
+  checkPaintInvalidationVisualRect(*absolute);
+  EXPECT_EQ(LayoutRect(222, 111, 50, 50), absolute->visualRect());
 }
 
 TEST_F(VisualRectMappingTest,
        ContainerOfAbsoluteAbovePaintInvalidationContainer) {
   enableCompositing();
   document().frame()->settings()->setPreferCompositingToLCDTextEnabled(true);
 
   setBodyInnerHTML(
       "<div id='container' style='position: absolute; top: 88px; left: 99px'>"
       "  <div style='height: 222px'></div>"
@@ skipping 28 matching lines @@
 
 TEST_F(VisualRectMappingTest, CSSClip) {
   setBodyInnerHTML(
       "<div id='container' style='position: absolute; top: 0px; left: 0px; "
       "    clip: rect(0px, 200px, 200px, 0px)'>"
       "  <div id='target' style='width: 400px; height: 400px'></div>"
       "</div>");
 
   LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target"));
 
-  LayoutRect targetLocalVisualRect = target->localVisualRect();
-  EXPECT_EQ(LayoutRect(0, 0, 400, 400), targetLocalVisualRect);
-  LayoutRect rect = targetLocalVisualRect;
-  EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(&layoutView(), rect));
-  EXPECT_EQ(LayoutRect(0, 0, 200, 200), rect);
-  EXPECT_EQ(rect, target->visualRect());
+  EXPECT_EQ(LayoutRect(0, 0, 400, 400), target->localVisualRect());
+  checkPaintInvalidationVisualRect(*target);
+  EXPECT_EQ(LayoutRect(0, 0, 200, 200), target->visualRect());
 }
 
 TEST_F(VisualRectMappingTest, ContainPaint) {
   setBodyInnerHTML(
       "<div id='container' style='position: absolute; top: 0px; left: 0px; "
       "    width: 200px; height: 200px; contain: paint'>"
       "  <div id='target' style='width: 400px; height: 400px'></div>"
       "</div>");
 
   LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target"));
 
-  LayoutRect targetLocalVisualRect = target->localVisualRect();
-  EXPECT_EQ(LayoutRect(0, 0, 400, 400), targetLocalVisualRect);
-  LayoutRect rect = targetLocalVisualRect;
-  EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(&layoutView(), rect));
-  EXPECT_EQ(LayoutRect(0, 0, 200, 200), rect);
-  EXPECT_EQ(rect, target->visualRect());
+  EXPECT_EQ(LayoutRect(0, 0, 400, 400), target->localVisualRect());
+  checkPaintInvalidationVisualRect(*target);
+  EXPECT_EQ(LayoutRect(0, 0, 200, 200), target->visualRect());
 }
 
 TEST_F(VisualRectMappingTest, FloatUnderInline) {
   setBodyInnerHTML(
       "<div style='position: absolute; top: 55px; left: 66px'>"
       "  <span id='span' style='position: relative; top: 100px; left: 200px'>"
       "    <div id='target' style='float: left; width: 33px; height: 44px'>"
       "    </div>"
       "  </span>"
       "</div>");
 
   LayoutBoxModelObject* span =
       toLayoutBoxModelObject(getLayoutObjectByElementId("span"));
   LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target"));
 
   LayoutRect targetVisualRect = target->localVisualRect();
   EXPECT_EQ(LayoutRect(0, 0, 33, 44), targetVisualRect);
 
   LayoutRect rect = targetVisualRect;
   EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(&layoutView(), rect));
   EXPECT_EQ(LayoutRect(66, 55, 33, 44), rect);
   EXPECT_EQ(rect, target->visualRect());
 
   rect = targetVisualRect;
-  EXPECT_TRUE(target->mapToVisualRectInAncestorSpace(span, rect));
-  EXPECT_EQ(LayoutRect(-200, -100, 33, 44), rect);
+
+  checkVisualRect(*target, *span, rect, LayoutRect(-200, -100, 33, 44));
 }
 
 TEST_F(VisualRectMappingTest, ShouldAccountForPreserve3d) {
   enableCompositing();
   setBodyInnerHTML(
       "<style>"
       "* { margin: 0; }"
       "#container {"
       "  transform: rotateX(-45deg);"
       "  width: 100px; height: 100px;"
       "}"
       "#target {"
       "  transform-style: preserve-3d; transform: rotateX(45deg);"
       "  background: lightblue;"
       "  width: 100px; height: 100px;"
       "}"
       "</style>"
       "<div id='container'><div id='target'></div></div>");
   LayoutBlock* container =
       toLayoutBlock(getLayoutObjectByElementId("container"));
   LayoutBlock* target = toLayoutBlock(getLayoutObjectByElementId("target"));
   LayoutRect originalRect(0, 0, 100, 100);
   // Multiply both matrices together before flattening.
   TransformationMatrix matrix = container->layer()->currentTransform();
+  matrix.flattenTo2d();
+  matrix *= target->layer()->currentTransform();
+  LayoutRect output(matrix.mapRect(FloatRect(originalRect)));
+
+  checkVisualRect(*target, *target->view(), originalRect, output);
+}
+
+TEST_F(VisualRectMappingTest, ShouldAccountForPreserve3dNested) {
+  enableCompositing();
+  setBodyInnerHTML(
+      "<style>"
+      "* { margin: 0; }"
+      "#container {"
+      "  transform-style: preserve-3d;"
+      "  transform: rotateX(-45deg);"
+      "  width: 100px; height: 100px;"
+      "}"
+      "#target {"
+      "  transform-style: preserve-3d; transform: rotateX(45deg);"
+      "  background: lightblue;"
+      "  width: 100px; height: 100px;"
+      "}"
+      "</style>"
+      "<div id='container'><div id='target'></div></div>");
+  LayoutBlock* container =
+      toLayoutBlock(getLayoutObjectByElementId("container"));
+  LayoutBlock* target = toLayoutBlock(getLayoutObjectByElementId("target"));
+  LayoutRect originalRect(0, 0, 100, 100);
+  // Multiply both matrices together before flattening.
+  TransformationMatrix matrix = container->layer()->currentTransform();
   matrix *= target->layer()->currentTransform();
-  matrix.flattenTo2d();
-  FloatRect output = matrix.mapRect(FloatRect(originalRect));
+  LayoutRect output(matrix.mapRect(FloatRect(originalRect)));
 
-  EXPECT_TRUE(
-      target->mapToVisualRectInAncestorSpace(target->view(), originalRect));
-  EXPECT_EQ(LayoutRect(enclosingIntRect(output)), originalRect);
+  checkVisualRect(*target, *target->view(), originalRect, output);
 }
 
 TEST_F(VisualRectMappingTest, ShouldAccountForPerspective) {
   enableCompositing();
   setBodyInnerHTML(
       "<style>"
       "* { margin: 0; }"
       "#container {"
       "  transform: rotateX(-45deg); perspective: 100px;"
       "  width: 100px; height: 100px;"
       "}"
       "#target {"
       "  transform-style: preserve-3d; transform: rotateX(45deg);"
       "  background: lightblue;"
       "  width: 100px; height: 100px;"
       "}"
       "</style>"
       "<div id='container'><div id='target'></div></div>");
   LayoutBlock* container =
       toLayoutBlock(getLayoutObjectByElementId("container"));
   LayoutBlock* target = toLayoutBlock(getLayoutObjectByElementId("target"));
   LayoutRect originalRect(0, 0, 100, 100);
   TransformationMatrix matrix = container->layer()->currentTransform();
+  matrix.flattenTo2d();
+  TransformationMatrix targetMatrix;
+  // getTransformfromContainter includes transform and perspective matrix
+  // of the container.
+  target->getTransformFromContainer(container, LayoutSize(), targetMatrix);
+  matrix *= targetMatrix;
+  LayoutRect output(matrix.mapRect(FloatRect(originalRect)));
+
+  checkVisualRect(*target, *target->view(), originalRect, output);
+}
+
+TEST_F(VisualRectMappingTest, ShouldAccountForPerspectiveNested) {
+  enableCompositing();
+  setBodyInnerHTML(
+      "<style>"
+      "* { margin: 0; }"
+      "#container {"
+      "  transform-style: preserve-3d;"
+      "  transform: rotateX(-45deg); perspective: 100px;"
+      "  width: 100px; height: 100px;"
+      "}"
+      "#target {"
+      "  transform-style: preserve-3d; transform: rotateX(45deg);"
+      "  background: lightblue;"
+      "  width: 100px; height: 100px;"
+      "}"
+      "</style>"
+      "<div id='container'><div id='target'></div></div>");
+  LayoutBlock* container =
+      toLayoutBlock(getLayoutObjectByElementId("container"));
+  LayoutBlock* target = toLayoutBlock(getLayoutObjectByElementId("target"));
+  LayoutRect originalRect(0, 0, 100, 100);
+  TransformationMatrix matrix = container->layer()->currentTransform();
   TransformationMatrix targetMatrix;
   // getTransformfromContainter includes transform and perspective matrix
   // of the container.
   target->getTransformFromContainer(container, LayoutSize(), targetMatrix);
   matrix *= targetMatrix;
-  matrix.flattenTo2d();
-  FloatRect output = matrix.mapRect(FloatRect(originalRect));
+  LayoutRect output(matrix.mapRect(FloatRect(originalRect)));
 
-  EXPECT_TRUE(
-      target->mapToVisualRectInAncestorSpace(target->view(), originalRect));
-  EXPECT_EQ(LayoutRect(enclosingIntRect(output)), originalRect);
+  checkVisualRect(*target, *target->view(), originalRect, output);
 }
 
 }  // namespace blink