Reduce the number of ObjectPaintProperties

third_party/WebKit/Source/core/paint/PaintPropertyTreeBuilderTest.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/paint/PaintPropertyTreeBuilderTest.h"
 
 #include "core/html/HTMLIFrameElement.h"
 #include "core/layout/LayoutTreeAsText.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintPropertyTreePrinter.h"
@@ skipping 57 matching lines @@
   RenderingTest::SetUp();
   enableCompositing();
 }
 
 void PaintPropertyTreeBuilderTest::TearDown() {
   RenderingTest::TearDown();
 
   Settings::setMockScrollbarsEnabled(false);
 }
 
-#define CHECK_VISUAL_RECT(expected, sourceLayoutObject, ancestorLayoutObject,  \
-                          slopFactor)                                          \
-  do {                                                                         \
-    std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create(); \
-    LayoutRect source((sourceLayoutObject)->localVisualRect());                \
-    source.moveBy((sourceLayoutObject)->paintOffset());                        \
-    const auto& contentsProperties =                                           \
-        *(ancestorLayoutObject)->paintProperties()->contentsProperties();      \
-    FloatRect actualFloatRect(source);                                         \
-    geometryMapper->sourceToDestinationVisualRect(                             \
-        *(sourceLayoutObject)->paintProperties()->localBorderBoxProperties(),  \
-        contentsProperties, actualFloatRect);                                  \
-    LayoutRect actual(actualFloatRect);                                        \
-    actual.moveBy(-(ancestorLayoutObject)->paintOffset());                     \
-    EXPECT_EQ(expected, actual)                                                \
-        << "GeometryMapper: expected: " << expected.toString()                 \
-        << ", actual: " << actual.toString();                                  \
-                                                                               \
-    if (slopFactor == LayoutUnit::max())                                       \
-      break;                                                                   \
-    LayoutRect slowPathRect = (sourceLayoutObject)->localVisualRect();         \
-    (sourceLayoutObject)                                                       \
-        ->mapToVisualRectInAncestorSpace(ancestorLayoutObject, slowPathRect);  \
-    if (slopFactor) {                                                          \
-      LayoutRect inflatedActual = LayoutRect(actual);                          \
-      inflatedActual.inflate(slopFactor);                                      \
-      SCOPED_TRACE(                                                            \
-          String::format("Old path rect: %s, Actual: %s, Inflated actual: %s", \
-                         slowPathRect.toString().ascii().data(),               \
-                         actual.toString().ascii().data(),                     \
-                         inflatedActual.toString().ascii().data()));           \
-      EXPECT_TRUE(slowPathRect.contains(LayoutRect(actual)));                  \
-      EXPECT_TRUE(inflatedActual.contains(slowPathRect));                      \
-    } else {                                                                   \
-      EXPECT_EQ(expected, slowPathRect)                                        \
-          << "Slow path: expected: " << slowPathRect.toString()                \
-          << ", actual: " << actual.toString().ascii().data();                 \
-    }                                                                          \
+#define CHECK_VISUAL_RECT(expected, sourceObject, ancestorObject, slopFactor) \
+  do {                                                                        \
+    if ((sourceObject)->hasLayer() && (ancestorObject)->hasLayer()) {         \
+      auto geometryMapper = GeometryMapper::create();                         \
+      LayoutRect source((sourceObject)->localVisualRect());                   \
+      source.moveBy((sourceObject)->paintOffset());                           \
+      const auto& contentsProperties =                                        \
+          *(ancestorObject)->paintProperties()->contentsProperties();         \
+      FloatRect actualFloatRect(source);                                      \
+      geometryMapper->sourceToDestinationVisualRect(                          \
+          *(sourceObject)->paintProperties()->localBorderBoxProperties(),     \
+          contentsProperties, actualFloatRect);                               \
+      LayoutRect actual(actualFloatRect);                                     \
+      actual.moveBy(-(ancestorObject)->paintOffset());                        \
+      SCOPED_TRACE("GeometryMapper: ");                                       \
+      EXPECT_EQ(expected, actual);                                            \
+    }                                                                         \
+                                                                              \
+    if (slopFactor == LayoutUnit::max())                                      \
+      break;                                                                  \
+    LayoutRect slowPathRect = (sourceObject)->localVisualRect();              \
+    (sourceObject)                                                            \
+        ->mapToVisualRectInAncestorSpace(ancestorObject, slowPathRect);       \
+    if (slopFactor) {                                                         \
+      LayoutRect inflatedExpected = LayoutRect(expected);                     \
+      inflatedExpected.inflate(slopFactor);                                   \
+      SCOPED_TRACE(String::format(                                            \
+          "Old path rect: %s, Expected: %s, Inflated expected: %s",           \
+          slowPathRect.toString().ascii().data(),                             \
+          expected.toString().ascii().data(),                                 \
+          inflatedExpected.toString().ascii().data()));                       \
+      EXPECT_TRUE(slowPathRect.contains(LayoutRect(expected)));               \
+      EXPECT_TRUE(inflatedExpected.contains(slowPathRect));                   \
+    } else {                                                                  \
+      SCOPED_TRACE("Slow path: ");                                            \
+      EXPECT_EQ(expected, slowPathRect);                                      \
+    }                                                                         \
   } while (0)
 
-#define CHECK_EXACT_VISUAL_RECT(expected, sourceLayoutObject, \
-                                ancestorLayoutObject)         \
-  CHECK_VISUAL_RECT(expected, sourceLayoutObject, ancestorLayoutObject, 0)
+#define CHECK_EXACT_VISUAL_RECT(expected, sourceObject, ancestorObject) \
+  CHECK_VISUAL_RECT(expected, sourceObject, ancestorObject, 0)
 
 INSTANTIATE_TEST_CASE_P(All, PaintPropertyTreeBuilderTest, ::testing::Bool());
 
 TEST_P(PaintPropertyTreeBuilderTest, FixedPosition) {
   loadTestData("fixed-position.html");
 
   Element* positionedScroll = document().getElementById("positionedScroll");
   positionedScroll->setScrollTop(3);
   Element* transformedScroll = document().getElementById("transformedScroll");
   transformedScroll->setScrollTop(5);
@@ skipping 396 matching lines @@
       "      <div id='greatGrandChildWithOpacity'"
       "          style='opacity: 0.2; width: 10px; height: 15px'></div>"
       "    </div>"
       "  </div>"
       "</div>");
 
   LayoutObject* nodeWithoutOpacity =
       document().getElementById("nodeWithoutOpacity")->layoutObject();
   const ObjectPaintProperties* nodeWithoutOpacityProperties =
       nodeWithoutOpacity->paintProperties();
-  EXPECT_NE(nullptr, nodeWithoutOpacityProperties);
+  EXPECT_EQ(nullptr, nodeWithoutOpacityProperties);
   CHECK_EXACT_VISUAL_RECT(LayoutRect(8, 8, 100, 200), nodeWithoutOpacity,
                           document().view()->layoutView());
 
   LayoutObject* childWithOpacity =
       document().getElementById("childWithOpacity")->layoutObject();
   const ObjectPaintProperties* childWithOpacityProperties =
       childWithOpacity->paintProperties();
   EXPECT_EQ(0.5f, childWithOpacityProperties->effect()->opacity());
   // childWithOpacity is the root effect node.
   EXPECT_NE(nullptr, childWithOpacityProperties->effect()->parent());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(8, 8, 50, 60), childWithOpacity,
                           document().view()->layoutView());
 
   LayoutObject* grandChildWithoutOpacity =
       document().getElementById("grandChildWithoutOpacity")->layoutObject();
-  EXPECT_NE(nullptr, grandChildWithoutOpacity->paintProperties());
+  EXPECT_EQ(nullptr, grandChildWithoutOpacity->paintProperties());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(8, 8, 20, 30), grandChildWithoutOpacity,
                           document().view()->layoutView());
 
   LayoutObject* greatGrandChildWithOpacity =
       document().getElementById("greatGrandChildWithOpacity")->layoutObject();
   const ObjectPaintProperties* greatGrandChildWithOpacityProperties =
       greatGrandChildWithOpacity->paintProperties();
   EXPECT_EQ(0.2f, greatGrandChildWithOpacityProperties->effect()->opacity());
   EXPECT_EQ(childWithOpacityProperties->effect(),
             greatGrandChildWithOpacityProperties->effect()->parent());
@@ skipping 878 matching lines @@
   setBodyInnerHTML(
       "<style>"
       "  #clip {"
       "    position: absolute;"
       "    left: 123px;"
       "    top: 456px;"
       "    clip: rect(10px, 80px, 70px, 40px);"
       "    width: 100px;"
       "    height: 100px;"
       "  }"
-      "  #abs {"
+      "  #absolute {"
       "    position: absolute;"
       "    left: 654px;"
       "    top: 321px;"
       "    width: 10px;"
       "    heght: 20px"
       "  }"
       "</style>"
       "<div id='clip'><div id='absolute'></div></div>");
 
   LayoutRect localClipRect(40, 10, 40, 60);
@@ skipping 14 matching lines @@
                     // TODO(crbug.com/599939): mapToVisualRectInAncestorSpace()
                     // doesn't apply css clip on the object itself.
                     LayoutUnit::max());
 
   auto* absolute = document().getElementById("absolute")->layoutObject();
   const ObjectPaintProperties* absPosProperties = absolute->paintProperties();
   EXPECT_EQ(clipProperties->cssClip(),
             absPosProperties->localBorderBoxProperties()->clip());
   EXPECT_EQ(framePreTranslation(),
             absPosProperties->localBorderBoxProperties()->transform());
-  EXPECT_EQ(LayoutPoint(123, 456), absolute->paintOffset());
+  EXPECT_EQ(LayoutPoint(777, 777), absolute->paintOffset());
   CHECK_VISUAL_RECT(LayoutRect(), absolute, document().view()->layoutView(),
                     // TODO(crbug.com/599939): CSS clip of fixed-position
                     // descendants is broken in
                     // mapToVisualRectInAncestorSpace().
                     LayoutUnit::max());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, CSSClipFixedPositionDescendantNonShared) {
   // This test is similar to CSSClipFixedPositionDescendant above, except that
   // now we have a parent overflow clip that should be escaped by the fixed
@@ skipping 1637 matching lines @@
   EXPECT_TRUE(properties->effect());
   EXPECT_NE(CompositorElementId(), properties->effect()->compositorElementId());
   EXPECT_TRUE(properties->effect()->requiresCompositingForAnimation());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, FloatUnderInline) {
   setBodyInnerHTML(
       "<div style='position: absolute; top: 55px; left: 66px'>"
       "  <span id='span'"
       "      style='position: relative; top: 100px; left: 200px; opacity: 0.5'>"
-      "    <div id='target' style='float: left; width: 33px; height: 44px'>"
+      "    <div id='target'"
+      "         style='overflow: hidden; float: left; width: 3px; height: 4px'>"
       "    </div>"
-      "  </span"
+      "  </span>"
       "</div>");
 
   LayoutObject* span = getLayoutObjectByElementId("span");
   const auto* effect = span->paintProperties()->effect();
   ASSERT_TRUE(effect);
   EXPECT_EQ(0.5f, effect->opacity());
 
   LayoutObject* target = getLayoutObjectByElementId("target");
   const auto* localBorderBoxProperties =
       target->paintProperties()->localBorderBoxProperties();
@@ skipping 166 matching lines @@
   Element* mask = document().getElementById("mask");
   mask->setAttribute(HTMLNames::styleAttr, "height: 200px");
   document().view()->updateAllLifecyclePhases();
 
   ASSERT_EQ(properties, paintPropertiesForElement("mask"));
   ASSERT_EQ(maskClip, properties->maskClip());
   EXPECT_EQ(FloatRoundedRect(8, 8, 100, 200), maskClip->clipRect());
 }
 
 }  // namespace blink