Store local border box property cache outside 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 64 matching lines @@
   Settings::setMockScrollbarsEnabled(false);
 }
 
 #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();         \
+          *(ancestorObject)->contentsProperties();                            \
       FloatRect actualFloatRect(source);                                      \
       geometryMapper->sourceToDestinationVisualRect(                          \
-          *(sourceObject)->paintProperties()->localBorderBoxProperties(),     \
-          contentsProperties, actualFloatRect);                               \
+          *(sourceObject)->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)                                                            \
@@ skipping 157 matching lines @@
   EXPECT_TRUE(framePreTranslation()->parent()->isRoot());
 
   EXPECT_EQ(TransformationMatrix().translate(0, -100),
             frameScrollTranslation()->matrix());
   EXPECT_EQ(framePreTranslation(), frameScrollTranslation()->parent());
   EXPECT_EQ(framePreTranslation(), frameContentClip()->localTransformSpace());
   EXPECT_EQ(FloatRoundedRect(0, 0, 800, 600), frameContentClip()->clipRect());
   EXPECT_TRUE(frameContentClip()->parent()->isRoot());
 
   if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
-    const auto* viewProperties = frameView->layoutView()->paintProperties();
-    EXPECT_EQ(nullptr, viewProperties->scrollTranslation());
+    // No scroll properties should be present.
+    EXPECT_EQ(nullptr, frameView->layoutView()->paintProperties());
   }
   CHECK_EXACT_VISUAL_RECT(LayoutRect(8, 8, 784, 10000),
                           document().body()->layoutObject(),
                           frameView->layoutView());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, Perspective) {
   setBodyInnerHTML(
       "<style>"
       "  #perspective {"
@@ skipping 203 matching lines @@
 
 TEST_P(PaintPropertyTreeBuilderTest, WillChangeContents) {
   setBodyInnerHTML(
       "<style> body { margin: 0 } </style>"
       "<div id='transform' style='margin-left: 50px; margin-top: 100px;"
       "    width: 400px; height: 300px;"
       "    will-change: transform, contents'>"
       "</div>");
 
   Element* transform = document().getElementById("transform");
-  const ObjectPaintProperties* transformProperties =
-      transform->layoutObject()->paintProperties();
-
-  EXPECT_EQ(nullptr, transformProperties->transform());
-  EXPECT_EQ(nullptr, transformProperties->paintOffsetTranslation());
-
+  EXPECT_EQ(nullptr, transform->layoutObject()->paintProperties());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(50, 100, 400, 300),
                           transform->layoutObject(),
                           document().view()->layoutView());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, RelativePositionInline) {
   loadTestData("relative-position-inline.html");
 
   Element* inlineBlock = document().getElementById("inline-block");
   const ObjectPaintProperties* inlineBlockProperties =
@@ skipping 130 matching lines @@
   EXPECT_EQ(0.6f, nodeWithOpacityProperties->effect()->opacity());
   EXPECT_NE(nullptr, nodeWithOpacityProperties->effect()->parent());
   EXPECT_EQ(nullptr, nodeWithOpacityProperties->transform());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(8, 8, 100, 200), nodeWithOpacity,
                           document().view()->layoutView());
 
   LayoutObject* childWithStackingContext =
       document().getElementById("childWithStackingContext")->layoutObject();
   const ObjectPaintProperties* childWithStackingContextProperties =
       childWithStackingContext->paintProperties();
-  EXPECT_EQ(nullptr, childWithStackingContextProperties->effect());
-  EXPECT_EQ(nullptr, childWithStackingContextProperties->transform());
+  EXPECT_EQ(nullptr, childWithStackingContextProperties);
   CHECK_EXACT_VISUAL_RECT(LayoutRect(8, 8, 50, 60), childWithStackingContext,
                           document().view()->layoutView());
 
   LayoutObject* grandChildWithOpacity =
       document().getElementById("grandChildWithOpacity")->layoutObject();
   const ObjectPaintProperties* grandChildWithOpacityProperties =
       grandChildWithOpacity->paintProperties();
   EXPECT_EQ(0.4f, grandChildWithOpacityProperties->effect()->opacity());
   EXPECT_EQ(nodeWithOpacityProperties->effect(),
             grandChildWithOpacityProperties->effect()->parent());
@@ skipping 368 matching lines @@
   LayoutObject& container =
       *document().getElementById("container")->layoutObject();
   const ObjectPaintProperties* containerProperties =
       container.paintProperties();
   EXPECT_EQ(TransformationMatrix().translate(20, 30),
             containerProperties->transform()->matrix());
   EXPECT_EQ(svgProperties->transform(),
             containerProperties->transform()->parent());
 
   Element* fixed = document().getElementById("fixed");
-  const ObjectPaintProperties* fixedProperties =
-      fixed->layoutObject()->paintProperties();
   // Ensure the fixed position element is rooted at the nearest transform
   // container.
   EXPECT_EQ(containerProperties->transform(),
-            fixedProperties->localBorderBoxProperties()->transform());
+            fixed->layoutObject()->localBorderBoxProperties()->transform());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, ControlClip) {
   setBodyInnerHTML(
       "<style>"
       "  body {"
       "    margin: 0;"
       "  }"
       "  input {"
       "    border-width: 5px;"
@@ skipping 221 matching lines @@
       "  <div id='child'"
       "      style='position:relative; width:100px; height: 200px;'></div>"
       "  <div style='height:10000px;'></div>"
       "</div>");
   FrameView* frameView = document().view();
 
   LayoutObject* scroller =
       document().getElementById("scroller")->layoutObject();
   const ObjectPaintProperties* scrollerProperties = scroller->paintProperties();
   LayoutObject* child = document().getElementById("child")->layoutObject();
-  const ObjectPaintProperties* childProperties = child->paintProperties();
 
   EXPECT_EQ(scrollerProperties->overflowClip(),
-            childProperties->localBorderBoxProperties()->clip());
+            child->localBorderBoxProperties()->clip());
   EXPECT_EQ(scrollerProperties->scrollTranslation(),
-            childProperties->localBorderBoxProperties()->transform());
-  EXPECT_NE(nullptr, childProperties->localBorderBoxProperties()->effect());
+            child->localBorderBoxProperties()->transform());
+  EXPECT_NE(nullptr, child->localBorderBoxProperties()->effect());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(0, 0, 400, 300), scroller,
                           frameView->layoutView());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(0, 0, 100, 200), child,
                           frameView->layoutView());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest,
        TreeContextUnclipFromParentStackingContext) {
   // This test verifies the tree builder correctly computes and records the
   // property tree context for a (pseudo) stacking context that has a scrolling
@@ skipping 16 matching lines @@
       "  }"
       "</style>"
       "<div id='scroller'>"
       "  <div id='child'></div>"
       "  <div id='forceScroll' style='height:10000px;'></div>"
       "</div>");
 
   auto& scroller = *document().getElementById("scroller")->layoutObject();
   const ObjectPaintProperties* scrollerProperties = scroller.paintProperties();
   LayoutObject& child = *document().getElementById("child")->layoutObject();
-  const ObjectPaintProperties* childProperties = child.paintProperties();
 
-  EXPECT_EQ(frameContentClip(),
-            childProperties->localBorderBoxProperties()->clip());
+  EXPECT_EQ(frameContentClip(), child.localBorderBoxProperties()->clip());
   EXPECT_EQ(frameScrollTranslation(),
-            childProperties->localBorderBoxProperties()->transform());
+            child.localBorderBoxProperties()->transform());
   EXPECT_EQ(scrollerProperties->effect(),
-            childProperties->localBorderBoxProperties()->effect());
+            child.localBorderBoxProperties()->effect());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(0, 0, 800, 10000), &scroller,
                           document().view()->layoutView());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(0, 0, 100, 200), &child,
                           document().view()->layoutView());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, TableCellLayoutLocation) {
   // This test verifies that the border box space of a table cell is being
   // correctly computed.  Table cells have weird location adjustment in our
   // layout/paint implementation.
@@ skipping 18 matching lines @@
       "    width: 100px;"
       "    height: 100px;"
       "  }"
       "</style>"
       "<table>"
       "  <tr><td></td><td></td></tr>"
       "  <tr><td></td><td><div id='target'></div></td></tr>"
       "</table>");
 
   LayoutObject& target = *document().getElementById("target")->layoutObject();
-  const ObjectPaintProperties* targetProperties = target.paintProperties();
-
   EXPECT_EQ(LayoutPoint(170, 170), target.paintOffset());
   EXPECT_EQ(framePreTranslation(),
-            targetProperties->localBorderBoxProperties()->transform());
+            target.localBorderBoxProperties()->transform());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(170, 170, 100, 100), &target,
                           document().view()->layoutView());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, CSSClipFixedPositionDescendant) {
   // This test verifies that clip tree hierarchy being generated correctly for
   // the hard case such that a fixed position element getting clipped by an
   // absolute position CSS clip.
   setBodyInnerHTML(
       "<style>"
@@ skipping 24 matching lines @@
   EXPECT_EQ(framePreTranslation(),
             clipProperties->cssClip()->localTransformSpace());
   EXPECT_EQ(FloatRoundedRect(FloatRect(absoluteClipRect)),
             clipProperties->cssClip()->clipRect());
   CHECK_VISUAL_RECT(absoluteClipRect, &clip, document().view()->layoutView(),
                     // TODO(crbug.com/599939): mapToVisualRectInAncestorSpace()
                     // doesn't apply css clip on the object itself.
                     LayoutUnit::max());
 
   LayoutObject* fixed = document().getElementById("fixed")->layoutObject();
-  const ObjectPaintProperties* fixedProperties = fixed->paintProperties();
   EXPECT_EQ(clipProperties->cssClip(),
-            fixedProperties->localBorderBoxProperties()->clip());
+            fixed->localBorderBoxProperties()->clip());
   EXPECT_EQ(framePreTranslation(),
-            fixedProperties->localBorderBoxProperties()->transform());
+            fixed->localBorderBoxProperties()->transform());
   EXPECT_EQ(LayoutPoint(654, 321), fixed->paintOffset());
   CHECK_VISUAL_RECT(LayoutRect(), fixed, document().view()->layoutView(),
                     // TODO(crbug.com/599939): CSS clip of fixed-position
                     // descendants is broken in
                     // mapToVisualRectInAncestorSpace().
                     LayoutUnit::max());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, CSSClipAbsPositionDescendant) {
   // This test verifies that clip tree hierarchy being generated correctly for
@@ skipping 32 matching lines @@
   EXPECT_EQ(framePreTranslation(),
             clipProperties->cssClip()->localTransformSpace());
   EXPECT_EQ(FloatRoundedRect(FloatRect(absoluteClipRect)),
             clipProperties->cssClip()->clipRect());
   CHECK_VISUAL_RECT(absoluteClipRect, clip, document().view()->layoutView(),
                     // 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());
+            absolute->localBorderBoxProperties()->clip());
   EXPECT_EQ(framePreTranslation(),
-            absPosProperties->localBorderBoxProperties()->transform());
+            absolute->localBorderBoxProperties()->transform());
   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
@@ skipping 51 matching lines @@
             clipProperties->cssClip()->clipRect());
   EXPECT_EQ(frameContentClip(),
             clipProperties->cssClipFixedPosition()->parent());
   EXPECT_EQ(overflowProperties->scrollTranslation(),
             clipProperties->cssClipFixedPosition()->localTransformSpace());
   EXPECT_EQ(FloatRoundedRect(FloatRect(absoluteClipRect)),
             clipProperties->cssClipFixedPosition()->clipRect());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(), clip, document().view()->layoutView());
 
   LayoutObject* fixed = document().getElementById("fixed")->layoutObject();
-  const ObjectPaintProperties* fixedProperties = fixed->paintProperties();
   EXPECT_EQ(clipProperties->cssClipFixedPosition(),
-            fixedProperties->localBorderBoxProperties()->clip());
+            fixed->localBorderBoxProperties()->clip());
   EXPECT_EQ(framePreTranslation(),
-            fixedProperties->localBorderBoxProperties()->transform());
+            fixed->localBorderBoxProperties()->transform());
   EXPECT_EQ(LayoutPoint(654, 321), fixed->paintOffset());
   CHECK_VISUAL_RECT(LayoutRect(), fixed, document().view()->layoutView(),
                     // TODO(crbug.com/599939): CSS clip of fixed-position
                     // descendants is broken in geometry mapping.
                     LayoutUnit::max());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, ColumnSpannerUnderRelativePositioned) {
   setBodyInnerHTML(
       "<style>"
@@ skipping 765 matching lines @@
       "<div id='clipper'"
       "    style='overflow: hidden; width: 400px; height: 300px;'>"
       "  <div id='child'"
       "      style='position: relative; width: 500px; height: 600px;'></div>"
       "</div>");
 
   LayoutBoxModelObject* clipper = toLayoutBoxModelObject(
       document().getElementById("clipper")->layoutObject());
   const ObjectPaintProperties* clipProperties = clipper->paintProperties();
   LayoutObject* child = document().getElementById("child")->layoutObject();
-  const ObjectPaintProperties* childProperties = child->paintProperties();
 
   // No scroll translation because the document does not scroll (not enough
   // content).
   EXPECT_TRUE(!frameScrollTranslation());
   EXPECT_EQ(framePreTranslation(),
-            clipProperties->localBorderBoxProperties()->transform());
-  EXPECT_EQ(frameContentClip(),
-            clipProperties->localBorderBoxProperties()->clip());
+            clipper->localBorderBoxProperties()->transform());
+  EXPECT_EQ(frameContentClip(), clipper->localBorderBoxProperties()->clip());
 
-  const auto& contentsProperties = *clipProperties->contentsProperties();
+  const auto& contentsProperties = *clipper->contentsProperties();
   EXPECT_EQ(LayoutPoint(30, 20), clipper->paintOffset());
   EXPECT_EQ(framePreTranslation(), contentsProperties.transform());
   EXPECT_EQ(clipProperties->overflowClip(), contentsProperties.clip());
 
   EXPECT_EQ(framePreTranslation(),
-            childProperties->localBorderBoxProperties()->transform());
+            child->localBorderBoxProperties()->transform());
   EXPECT_EQ(clipProperties->overflowClip(),
-            childProperties->localBorderBoxProperties()->clip());
+            child->localBorderBoxProperties()->clip());
 
-  EXPECT_NE(nullptr, childProperties->localBorderBoxProperties()->effect());
+  EXPECT_NE(nullptr, child->localBorderBoxProperties()->effect());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(0, 0, 500, 600), child, clipper);
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, ContainsPaintContentsTreeState) {
   setBodyInnerHTML(
       "<style>body { margin: 20px 30px; }</style>"
       "<div id='clipper'"
       "    style='contain: paint; width: 300px; height: 200px;'>"
       "  <div id='child'"
       "      style='position: relative; width: 400px; height: 500px;'></div>"
       "</div>");
 
   LayoutBoxModelObject* clipper = toLayoutBoxModelObject(
       document().getElementById("clipper")->layoutObject());
   const ObjectPaintProperties* clipProperties = clipper->paintProperties();
   LayoutObject* child = document().getElementById("child")->layoutObject();
-  const ObjectPaintProperties* childProperties = child->paintProperties();
 
   // No scroll translation because the document does not scroll (not enough
   // content).
   EXPECT_TRUE(!frameScrollTranslation());
   EXPECT_EQ(framePreTranslation(),
-            clipProperties->localBorderBoxProperties()->transform());
-  EXPECT_EQ(frameContentClip(),
-            clipProperties->localBorderBoxProperties()->clip());
+            clipper->localBorderBoxProperties()->transform());
+  EXPECT_EQ(frameContentClip(), clipper->localBorderBoxProperties()->clip());
 
-  const auto& contentsProperties = *clipProperties->contentsProperties();
+  const auto& contentsProperties = *clipper->contentsProperties();
   EXPECT_EQ(LayoutPoint(30, 20), clipper->paintOffset());
   EXPECT_EQ(framePreTranslation(), contentsProperties.transform());
   EXPECT_EQ(clipProperties->overflowClip(), contentsProperties.clip());
 
   EXPECT_EQ(framePreTranslation(),
-            childProperties->localBorderBoxProperties()->transform());
+            child->localBorderBoxProperties()->transform());
   EXPECT_EQ(clipProperties->overflowClip(),
-            childProperties->localBorderBoxProperties()->clip());
+            child->localBorderBoxProperties()->clip());
 
-  EXPECT_NE(nullptr, childProperties->localBorderBoxProperties()->effect());
+  EXPECT_NE(nullptr, child->localBorderBoxProperties()->effect());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(0, 0, 400, 500), child, clipper);
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, OverflowScrollContentsTreeState) {
   // This test verifies the tree builder correctly computes and records the
   // property tree context for a (pseudo) stacking context that is scrolled by a
   // containing block that is not one of the painting ancestors.
   setBodyInnerHTML(
       "<style>body { margin: 20px 30px; }</style>"
       "<div id='clipper' style='overflow:scroll; width:400px; height:300px;'>"
       "  <div id='child'"
       "      style='position:relative; width:500px; height: 600px;'></div>"
       "  <div style='width: 200px; height: 10000px'></div>"
       "</div>"
       "<div id='forceScroll' style='height: 4000px;'></div>");
 
   Element* clipperElement = document().getElementById("clipper");
   clipperElement->scrollTo(1, 2);
 
   LayoutBoxModelObject* clipper =
       toLayoutBoxModelObject(clipperElement->layoutObject());
   const ObjectPaintProperties* clipProperties = clipper->paintProperties();
   LayoutObject* child = document().getElementById("child")->layoutObject();
-  const ObjectPaintProperties* childProperties = child->paintProperties();
 
   EXPECT_EQ(frameScrollTranslation(),
-            clipProperties->localBorderBoxProperties()->transform());
-  EXPECT_EQ(frameContentClip(),
-            clipProperties->localBorderBoxProperties()->clip());
+            clipper->localBorderBoxProperties()->transform());
+  EXPECT_EQ(frameContentClip(), clipper->localBorderBoxProperties()->clip());
 
-  const auto& contentsProperties = *clipProperties->contentsProperties();
+  const auto& contentsProperties = *clipper->contentsProperties();
   EXPECT_EQ(LayoutPoint(30, 20), clipper->paintOffset());
   EXPECT_EQ(clipProperties->scrollTranslation(),
             contentsProperties.transform());
   EXPECT_EQ(clipProperties->overflowClip(), contentsProperties.clip());
 
   EXPECT_EQ(clipProperties->scrollTranslation(),
-            childProperties->localBorderBoxProperties()->transform());
+            child->localBorderBoxProperties()->transform());
   EXPECT_EQ(clipProperties->overflowClip(),
-            childProperties->localBorderBoxProperties()->clip());
+            child->localBorderBoxProperties()->clip());
 
   CHECK_EXACT_VISUAL_RECT(LayoutRect(0, 0, 500, 600), child, clipper);
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, OverflowScrollWithRoundedRect) {
   setBodyInnerHTML(
       "<style>"
       "  * { margin: 0; }"
       "  ::-webkit-scrollbar {"
       "    width: 13px;"
@@ skipping 50 matching lines @@
 
   LayoutBoxModelObject* clipper = toLayoutBoxModelObject(
       document().getElementById("clipper")->layoutObject());
   const ObjectPaintProperties* clipProperties = clipper->paintProperties();
   LayoutObject* child = document().getElementById("child")->layoutObject();
 
   // No scroll translation because the document does not scroll (not enough
   // content).
   EXPECT_TRUE(!frameScrollTranslation());
   EXPECT_EQ(framePreTranslation(),
-            clipProperties->localBorderBoxProperties()->transform());
+            clipper->localBorderBoxProperties()->transform());
   // CSS clip on an element causes it to clip itself, not just descendants.
   EXPECT_EQ(clipProperties->cssClip(),
-            clipProperties->localBorderBoxProperties()->clip());
+            clipper->localBorderBoxProperties()->clip());
 
-  const auto& contentsProperties = *clipProperties->contentsProperties();
+  const auto& contentsProperties = *clipper->contentsProperties();
   EXPECT_EQ(LayoutPoint(30, 20), clipper->paintOffset());
   EXPECT_EQ(framePreTranslation(), contentsProperties.transform());
   EXPECT_EQ(clipProperties->cssClip(), contentsProperties.clip());
 
   CHECK_EXACT_VISUAL_RECT(LayoutRect(0, 0, 400, 500), child, clipper);
 }
 
 TEST_P(PaintPropertyTreeBuilderTest,
        SvgLocalToBorderBoxTransformContentsTreeState) {
   setBodyInnerHTML(
       "<style>"
       "  body {"
       "    margin: 20px 30px;"
       "  }"
       "  svg {"
       "    position: absolute;"
       "  }"
       "  rect {"
       "    transform: translate(100px, 100px);"
       "  }"
       "</style>"
       "<svg id='svgWithViewBox' width='100px' height='100px' viewBox='50 50 "
       "100 100'>"
       "  <rect id='rect' width='100px' height='100px' />"
       "</svg>");
 
   LayoutObject& svgWithViewBox =
       *document().getElementById("svgWithViewBox")->layoutObject();
-  const ObjectPaintProperties* svgWithViewBoxProperties =
-      svgWithViewBox.paintProperties();
+  EXPECT_EQ(framePreTranslation(),
+            svgWithViewBox.localBorderBoxProperties()->transform());
 
-  EXPECT_EQ(framePreTranslation(),
-            svgWithViewBoxProperties->localBorderBoxProperties()->transform());
-
-  const auto& contentsProperties =
-      *svgWithViewBoxProperties->contentsProperties();
   EXPECT_EQ(LayoutPoint(30, 20), svgWithViewBox.paintOffset());
+  const auto& contentsProperties = *svgWithViewBox.contentsProperties();
   EXPECT_EQ(framePreTranslation(), contentsProperties.transform());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, OverflowHiddenScrollProperties) {
   setBodyInnerHTML(
       "<style>"
       "  body {"
       "    margin: 0px;"
       "  }"
       "  #overflowHidden {"
@@ skipping 426 matching lines @@
   const ObjectPaintProperties* filterProperties =
       getLayoutObjectByElementId("filter")->paintProperties();
   EXPECT_TRUE(filterProperties->filter()->parent()->isRoot());
   EXPECT_EQ(frameScrollTranslation(),
             filterProperties->filter()->localTransformSpace());
   EXPECT_EQ(clipProperties->overflowClip(),
             filterProperties->filter()->outputClip());
 
   const PropertyTreeState& childPaintState =
       *getLayoutObjectByElementId("child")
-           ->paintProperties()
            ->localBorderBoxProperties();
 
   // This will change once we added clip expansion node.
   EXPECT_EQ(filterProperties->filter()->outputClip(), childPaintState.clip());
   EXPECT_EQ(filterProperties->filter(), childPaintState.effect());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, TransformOriginWithAndWithoutTransform) {
   setBodyInnerHTML(
       "<style>"
@@ skipping 70 matching lines @@
       "  #ancestor { position: absolute; overflow: hidden }"
       "  #descendant { position: absolute }"
       "</style>"
       "<div id='ancestor'>"
       "  <div id='descendant'></div>"
       "</div>");
 
   LayoutObject* ancestor = getLayoutObjectByElementId("ancestor");
   LayoutObject* descendant = getLayoutObjectByElementId("descendant");
   EXPECT_EQ(ancestor->paintProperties()->overflowClip(),
-            descendant->paintProperties()->localBorderBoxProperties()->clip());
+            descendant->localBorderBoxProperties()->clip());
 
   toElement(ancestor->node())
       ->setAttribute(HTMLNames::styleAttr, "position: static");
   document().view()->updateAllLifecyclePhases();
   EXPECT_NE(ancestor->paintProperties()->overflowClip(),
-            descendant->paintProperties()->localBorderBoxProperties()->clip());
+            descendant->localBorderBoxProperties()->clip());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest,
        TransformNodeNotAnimatedHasNoCompositorElementId) {
   setBodyInnerHTML("<div id='target' style='transform: translateX(2em)'></div");
   const ObjectPaintProperties* properties = paintPropertiesForElement("target");
   EXPECT_TRUE(properties->transform());
   EXPECT_EQ(CompositorElementId(),
             properties->transform()->compositorElementId());
 }
@@ skipping 34 matching lines @@
       "    </div>"
       "  </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();
-  ASSERT_TRUE(localBorderBoxProperties);
+  ASSERT_TRUE(target->localBorderBoxProperties());
   EXPECT_EQ(LayoutPoint(66, 55), target->paintOffset());
-  EXPECT_EQ(effect, localBorderBoxProperties->effect());
+  EXPECT_EQ(effect, target->localBorderBoxProperties()->effect());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, ScrollTranslationHasCompositorElementId) {
   setBodyInnerHTML(
       "<div id='target' style='overflow: auto; width: 100px; height: 100px'>"
       "  <div style='width: 200px; height: 200px'></div>"
       "</div>");
 
   const ObjectPaintProperties* properties = paintPropertiesForElement("target");
   EXPECT_NE(CompositorElementId(),
@@ skipping 20 matching lines @@
 TEST_P(PaintPropertyTreeBuilderTest, MaskSimple) {
   setBodyInnerHTML(
       "<div id='target' style='width:300px; height:200px; "
       "-webkit-mask:linear-gradient(red,red)'>"
       "  Lorem ipsum"
       "</div>");
 
   const ObjectPaintProperties* properties = paintPropertiesForElement("target");
   const ClipPaintPropertyNode* outputClip = properties->maskClip();
 
-  EXPECT_EQ(outputClip, properties->localBorderBoxProperties()->clip());
+  const auto* target = document().getElementById("target")->layoutObject();
+  EXPECT_EQ(outputClip, target->localBorderBoxProperties()->clip());
   EXPECT_EQ(frameContentClip(), outputClip->parent());
   EXPECT_EQ(FloatRoundedRect(8, 8, 300, 200), outputClip->clipRect());
 
-  EXPECT_EQ(properties->effect(),
-            properties->localBorderBoxProperties()->effect());
+  EXPECT_EQ(properties->effect(), target->localBorderBoxProperties()->effect());
   EXPECT_TRUE(properties->effect()->parent()->isRoot());
   EXPECT_EQ(SkBlendMode::kSrcOver, properties->effect()->blendMode());
   EXPECT_EQ(outputClip, properties->effect()->outputClip());
 
   EXPECT_EQ(properties->effect(), properties->mask()->parent());
   EXPECT_EQ(SkBlendMode::kDstIn, properties->mask()->blendMode());
   EXPECT_EQ(outputClip, properties->mask()->outputClip());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, MaskEscapeClip) {
   // This test verifies an abs-pos element still escape the scroll of a
   // static-pos ancestor, but gets clipped due to the presence of a mask.
   setBodyInnerHTML(
       "<div style='width:300px; height:200px; overflow:scroll;'>"
       "  <div id='target' style='width:200px; height:300px; "
       "-webkit-mask:linear-gradient(red,red); border:10px dashed black; "
       "overflow:hidden;'>"
       "    <div id='absolute' style='position:absolute; left:0; top:0;'>Lorem "
       "ipsum</div>"
       "  </div>"
       "</div>");
 
   const ObjectPaintProperties* properties = paintPropertiesForElement("target");
   const ClipPaintPropertyNode* overflowClip1 = properties->maskClip()->parent();
   const ClipPaintPropertyNode* maskClip = properties->maskClip();
   const ClipPaintPropertyNode* overflowClip2 = properties->overflowClip();
+  const auto* target = document().getElementById("target")->layoutObject();
   const TransformPaintPropertyNode* scrollTranslation =
-      properties->localBorderBoxProperties()->transform();
+      target->localBorderBoxProperties()->transform();
 
   EXPECT_EQ(frameContentClip(), overflowClip1->parent());
   EXPECT_EQ(FloatRoundedRect(8, 8, 300, 200), overflowClip1->clipRect());
   EXPECT_EQ(framePreTranslation(), overflowClip1->localTransformSpace());
 
-  EXPECT_EQ(maskClip, properties->localBorderBoxProperties()->clip());
+  EXPECT_EQ(maskClip, target->localBorderBoxProperties()->clip());
   EXPECT_EQ(overflowClip1, maskClip->parent());
   EXPECT_EQ(FloatRoundedRect(8, 8, 220, 320), maskClip->clipRect());
   EXPECT_EQ(scrollTranslation, maskClip->localTransformSpace());
 
   EXPECT_EQ(maskClip, overflowClip2->parent());
   EXPECT_EQ(FloatRoundedRect(18, 18, 200, 300), overflowClip2->clipRect());
   EXPECT_EQ(scrollTranslation, overflowClip2->localTransformSpace());
 
-  EXPECT_EQ(properties->effect(),
-            properties->localBorderBoxProperties()->effect());
+  EXPECT_EQ(properties->effect(), target->localBorderBoxProperties()->effect());
   EXPECT_TRUE(properties->effect()->parent()->isRoot());
   EXPECT_EQ(SkBlendMode::kSrcOver, properties->effect()->blendMode());
   EXPECT_EQ(maskClip, properties->effect()->outputClip());
 
   EXPECT_EQ(properties->effect(), properties->mask()->parent());
   EXPECT_EQ(SkBlendMode::kDstIn, properties->mask()->blendMode());
   EXPECT_EQ(maskClip, properties->mask()->outputClip());
 
-  const ObjectPaintProperties* properties2 =
-      paintPropertiesForElement("absolute");
+  const auto* absolute = document().getElementById("absolute")->layoutObject();
   EXPECT_EQ(framePreTranslation(),
-            properties2->localBorderBoxProperties()->transform());
-  EXPECT_EQ(maskClip, properties2->localBorderBoxProperties()->clip());
+            absolute->localBorderBoxProperties()->transform());
+  EXPECT_EQ(maskClip, absolute->localBorderBoxProperties()->clip());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, MaskInline) {
   loadAhem();
   // This test verifies CSS mask applied on an inline element is clipped to
   // the line box of the said element. In this test the masked element has
   // only one box, and one of the child element overflows the box.
   setBodyInnerHTML(
       "<style>* { font-family:Ahem; font-size:16px; }</style>"
       "Lorem"
       "<span id='target' style='-webkit-mask:linear-gradient(red,red);'>"
       "  ipsum"
       "  <span id='overflowing' style='position:relative; font-size:32px;'>"
       "    dolor"
       "  </span>"
       "  sit amet,"
       "</span>");
 
   const ObjectPaintProperties* properties = paintPropertiesForElement("target");
   const ClipPaintPropertyNode* outputClip = properties->maskClip();
+  const auto* target = document().getElementById("target")->layoutObject();
 
-  EXPECT_EQ(outputClip, properties->localBorderBoxProperties()->clip());
+  EXPECT_EQ(outputClip, target->localBorderBoxProperties()->clip());
   EXPECT_EQ(frameContentClip(), outputClip->parent());
   EXPECT_EQ(FloatRoundedRect(88, 21, 448, 16), outputClip->clipRect());
 
-  EXPECT_EQ(properties->effect(),
-            properties->localBorderBoxProperties()->effect());
+  EXPECT_EQ(properties->effect(), target->localBorderBoxProperties()->effect());
   EXPECT_TRUE(properties->effect()->parent()->isRoot());
   EXPECT_EQ(SkBlendMode::kSrcOver, properties->effect()->blendMode());
   EXPECT_EQ(outputClip, properties->effect()->outputClip());
 
   EXPECT_EQ(properties->effect(), properties->mask()->parent());
   EXPECT_EQ(SkBlendMode::kDstIn, properties->mask()->blendMode());
   EXPECT_EQ(outputClip, properties->mask()->outputClip());
 
-  const ObjectPaintProperties* properties2 =
-      paintPropertiesForElement("overflowing");
-  EXPECT_EQ(outputClip, properties2->localBorderBoxProperties()->clip());
+  const auto* overflowing =
+      document().getElementById("overflowing")->layoutObject();
+  EXPECT_EQ(outputClip, overflowing->localBorderBoxProperties()->clip());
   EXPECT_EQ(properties->effect(),
-            properties2->localBorderBoxProperties()->effect());
+            overflowing->localBorderBoxProperties()->effect());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, MaskClipNodeInvalidation) {
   // This test verifies the clip node generated for mask's implicit clip
   // is correctly invalidated when a box resizes.
   setBodyInnerHTML(
       "<style>"
       "#mask {"
       "  width: 100px;"
       "  height:100px;"
@@ skipping 90 matching lines @@
       "</svg>");
 
   LayoutObject& svgRoot = *document().getElementById("svgroot")->layoutObject();
   const ObjectPaintProperties* svgRootProperties = svgRoot.paintProperties();
   EXPECT_TRUE(svgRootProperties->effect());
   EXPECT_EQ(EffectPaintPropertyNode::root(),
             svgRootProperties->effect()->parent());
 }
 
 }  // namespace blink