Combine LayoutObject::previousPaintOffset and paintOffset in paint properties

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 34 matching lines @@
 
 const ScrollPaintPropertyNode* PaintPropertyTreeBuilderTest::frameScroll(
     FrameView* frameView) {
   if (!frameView)
     frameView = document().view();
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled())
     return frameView->layoutView()->paintProperties()->scroll();
   return frameView->scroll();
 }
 
-LayoutPoint PaintPropertyTreeBuilderTest::paintOffset(
-    const LayoutObject* object) {
-  return object->paintProperties()->localBorderBoxProperties()->paintOffset;
-}
-
 const ObjectPaintProperties*
 PaintPropertyTreeBuilderTest::paintPropertiesForElement(const char* name) {
   return document().getElementById(name)->layoutObject()->paintProperties();
 }
 
 void PaintPropertyTreeBuilderTest::SetUp() {
   Settings::setMockScrollbarsEnabled(true);
 
   RenderingTest::SetUp();
   enableCompositing();
 }
 
 void PaintPropertyTreeBuilderTest::TearDown() {
   RenderingTest::TearDown();
 
   Settings::setMockScrollbarsEnabled(false);
 }
 
 #define CHECK_VISUAL_RECT(expected, sourceLayoutObject, ancestorLayoutObject,  \
                           slopFactor)                                          \
   do {                                                                         \
     GeometryMapper geometryMapper;                                             \
     LayoutRect source((sourceLayoutObject)->localVisualRect());                \
-    source.moveBy((sourceLayoutObject)                                         \
-                      ->paintProperties()                                      \
-                      ->localBorderBoxProperties()                             \
-                      ->paintOffset);                                          \
+    source.moveBy((sourceLayoutObject)->paintOffset());                        \
     bool success = false;                                                      \
     auto contentsProperties =                                                  \
         (ancestorLayoutObject)->paintProperties()->contentsProperties();       \
     LayoutRect actual =                                                        \
         LayoutRect(geometryMapper.mapToVisualRectInDestinationSpace(           \
-            FloatRect(source), (sourceLayoutObject)                            \
-                                   ->paintProperties()                         \
-                                   ->localBorderBoxProperties()                \
-                                   ->propertyTreeState,                        \
-            contentsProperties.propertyTreeState, success));                   \
+            FloatRect(source), *(sourceLayoutObject)                           \
+                                    ->paintProperties()                        \
+                                    ->localBorderBoxProperties(),              \
+            contentsProperties, success));                                     \
     ASSERT_TRUE(success);                                                      \
-    actual.moveBy(-contentsProperties.paintOffset);                            \
+    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) {                                                          \
@@ skipping 930 matching lines @@
             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()
-                ->propertyTreeState.transform());
+            fixedProperties->localBorderBoxProperties()->transform());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, ControlClip) {
   setBodyInnerHTML(
       "<style>"
       "  body {"
       "    margin: 0;"
       "  }"
       "  input {"
       "    border-width: 5px;"
@@ skipping 223 matching lines @@
       "  <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()->propertyTreeState.clip());
+  EXPECT_EQ(scrollerProperties->overflowClip(),
+            childProperties->localBorderBoxProperties()->clip());
   EXPECT_EQ(scrollerProperties->scrollTranslation(),
-            childProperties->localBorderBoxProperties()
-                ->propertyTreeState.transform());
-  EXPECT_NE(
-      nullptr,
-      childProperties->localBorderBoxProperties()->propertyTreeState.effect());
+            childProperties->localBorderBoxProperties()->transform());
+  EXPECT_NE(nullptr, childProperties->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 18 matching lines @@
       "<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()->propertyTreeState.clip());
+  EXPECT_EQ(frameContentClip(),
+            childProperties->localBorderBoxProperties()->clip());
   EXPECT_EQ(frameScrollTranslation(),
-            childProperties->localBorderBoxProperties()
-                ->propertyTreeState.transform());
-  EXPECT_EQ(
-      scrollerProperties->effect(),
-      childProperties->localBorderBoxProperties()->propertyTreeState.effect());
+            childProperties->localBorderBoxProperties()->transform());
+  EXPECT_EQ(scrollerProperties->effect(),
+            childProperties->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 20 matching lines @@
       "  }"
       "</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),
-            targetProperties->localBorderBoxProperties()->paintOffset);
-  EXPECT_EQ(framePreTranslation(), targetProperties->localBorderBoxProperties()
-                                       ->propertyTreeState.transform());
+  EXPECT_EQ(LayoutPoint(170, 170), target.paintOffset());
+  EXPECT_EQ(framePreTranslation(),
+            targetProperties->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 25 matching lines @@
             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()->propertyTreeState.clip());
-  EXPECT_EQ(framePreTranslation(), fixedProperties->localBorderBoxProperties()
-                                       ->propertyTreeState.transform());
-  EXPECT_EQ(LayoutPoint(654, 321),
-            fixedProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(clipProperties->cssClip(),
+            fixedProperties->localBorderBoxProperties()->clip());
+  EXPECT_EQ(framePreTranslation(),
+            fixedProperties->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
   // the hard case such that a fixed position element getting clipped by an
@@ skipping 32 matching lines @@
             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()->propertyTreeState.clip());
-  EXPECT_EQ(framePreTranslation(), absPosProperties->localBorderBoxProperties()
-                                       ->propertyTreeState.transform());
-  EXPECT_EQ(LayoutPoint(123, 456),
-            absPosProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(clipProperties->cssClip(),
+            absPosProperties->localBorderBoxProperties()->clip());
+  EXPECT_EQ(framePreTranslation(),
+            absPosProperties->localBorderBoxProperties()->transform());
+  EXPECT_EQ(LayoutPoint(123, 456), 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 51 matching lines @@
   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()->propertyTreeState.clip());
-  EXPECT_EQ(framePreTranslation(), fixedProperties->localBorderBoxProperties()
-                                       ->propertyTreeState.transform());
-  EXPECT_EQ(LayoutPoint(654, 321),
-            fixedProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(clipProperties->cssClipFixedPosition(),
+            fixedProperties->localBorderBoxProperties()->clip());
+  EXPECT_EQ(framePreTranslation(),
+            fixedProperties->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>"
       "  #spanner {"
       "    column-span: all;"
       "    opacity: 0.5;"
       "    width: 100px;"
       "    height: 100px;"
       "  }"
       "</style>"
       "<div style='columns: 3; position: absolute; top: 44px; left: 55px;'>"
       "  <div style='position: relative; top: 100px; left: 100px'>"
       "    <div id='spanner'></div>"
       "  </div>"
       "</div>");
 
   LayoutObject* spanner = getLayoutObjectByElementId("spanner");
-  EXPECT_EQ(
-      LayoutPoint(55, 44),
-      spanner->paintProperties()->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(LayoutPoint(55, 44), spanner->paintOffset());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(55, 44, 100, 100), spanner,
                           document().view()->layoutView());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, FractionalPaintOffset) {
   setBodyInnerHTML(
       "<style>"
       "  * { margin: 0; }"
       "  div { position: absolute; }"
       "  #a {"
       "    width: 70px;"
       "    height: 70px;"
       "    left: 0.1px;"
       "    top: 0.3px;"
       "  }"
       "  #b {"
       "    width: 40px;"
       "    height: 40px;"
       "    left: 0.5px;"
       "    top: 11.1px;"
       "  }"
       "</style>"
       "<div id='a'>"
       "  <div id='b'></div>"
       "</div>");
   FrameView* frameView = document().view();
 
   LayoutObject* a = document().getElementById("a")->layoutObject();
-  const ObjectPaintProperties* aProperties = a->paintProperties();
   LayoutPoint aPaintOffset = LayoutPoint(FloatPoint(0.1, 0.3));
-  EXPECT_EQ(aPaintOffset, aProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(aPaintOffset, a->paintOffset());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(LayoutUnit(0.1), LayoutUnit(0.3),
                                      LayoutUnit(70), LayoutUnit(70)),
                           a, frameView->layoutView());
 
   LayoutObject* b = document().getElementById("b")->layoutObject();
-  const ObjectPaintProperties* bProperties = b->paintProperties();
   LayoutPoint bPaintOffset = aPaintOffset + LayoutPoint(FloatPoint(0.5, 11.1));
-  EXPECT_EQ(bPaintOffset, bProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(bPaintOffset, b->paintOffset());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(LayoutUnit(0.1), LayoutUnit(0.3),
                                      LayoutUnit(70), LayoutUnit(70)),
                           a, frameView->layoutView());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, PaintOffsetWithBasicPixelSnapping) {
   setBodyInnerHTML(
       "<style>"
       "  * { margin: 0; }"
       "  div { position: relative; }"
@@ skipping 24 matching lines @@
 
   LayoutObject* b = document().getElementById("b")->layoutObject();
   const ObjectPaintProperties* bProperties = b->paintProperties();
   EXPECT_EQ(TransformationMatrix().translate3d(0, 0, 0),
             bProperties->transform()->matrix());
   // The paint offset transform should be snapped from (0.3,0.3) to (0,0).
   EXPECT_EQ(TransformationMatrix().translate(0, 0),
             bProperties->transform()->parent()->matrix());
   // The residual subpixel adjustment should be (0.3,0.3) - (0,0) = (0.3,0.3).
   LayoutPoint subpixelAccumulation = LayoutPoint(FloatPoint(0.3, 0.3));
-  EXPECT_EQ(subpixelAccumulation,
-            bProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(subpixelAccumulation, b->paintOffset());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(FloatRect(0.3, 0.3, 40, 40)), b,
                           frameView->layoutView());
 
   // c's painted should start at subpixelAccumulation + (0.1,0.1) = (0.4,0.4).
   LayoutObject* c = document().getElementById("c")->layoutObject();
   LayoutPoint cPaintOffset =
       subpixelAccumulation + LayoutPoint(FloatPoint(0.1, 0.1));
-  const ObjectPaintProperties* cProperties = c->paintProperties();
-  EXPECT_EQ(cPaintOffset, cProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(cPaintOffset, c->paintOffset());
   // Visual rects via the non-paint properties system use enclosingIntRect
   // before applying transforms, because they are computed bottom-up and
   // therefore can't apply pixel snapping. Therefore apply a slop of 1px.
   CHECK_VISUAL_RECT(LayoutRect(FloatRect(0.4, 0.4, 40, 40)), c,
                     frameView->layoutView(), 1);
 }
 
 TEST_P(PaintPropertyTreeBuilderTest,
        PaintOffsetWithPixelSnappingThroughTransform) {
   setBodyInnerHTML(
@@ skipping 28 matching lines @@
   LayoutObject* b = document().getElementById("b")->layoutObject();
   const ObjectPaintProperties* bProperties = b->paintProperties();
   EXPECT_EQ(TransformationMatrix().translate3d(0, 0, 0),
             bProperties->transform()->matrix());
   // The paint offset transform should be snapped from (0.7,0.7) to (1,1).
   EXPECT_EQ(TransformationMatrix().translate(1, 1),
             bProperties->transform()->parent()->matrix());
   // The residual subpixel adjustment should be (0.7,0.7) - (1,1) = (-0.3,-0.3).
   LayoutPoint subpixelAccumulation =
       LayoutPoint(LayoutPoint(FloatPoint(0.7, 0.7)) - LayoutPoint(1, 1));
-  EXPECT_EQ(subpixelAccumulation,
-            bProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(subpixelAccumulation, b->paintOffset());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(LayoutUnit(0.7), LayoutUnit(0.7),
                                      LayoutUnit(40), LayoutUnit(40)),
                           b, frameView->layoutView());
 
   // c's painting should start at subpixelAccumulation + (0.7,0.7) = (0.4,0.4).
   LayoutObject* c = document().getElementById("c")->layoutObject();
   LayoutPoint cPaintOffset =
       subpixelAccumulation + LayoutPoint(FloatPoint(0.7, 0.7));
-  const ObjectPaintProperties* cProperties = c->paintProperties();
-  EXPECT_EQ(cPaintOffset, cProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(cPaintOffset, c->paintOffset());
   // Visual rects via the non-paint properties system use enclosingIntRect
   // before applying transforms, because they are computed bottom-up and
   // therefore can't apply pixel snapping. Therefore apply a slop of 1px.
   CHECK_VISUAL_RECT(LayoutRect(LayoutUnit(0.7) + LayoutUnit(0.7),
                                LayoutUnit(0.7) + LayoutUnit(0.7),
                                LayoutUnit(40), LayoutUnit(40)),
                     c, frameView->layoutView(), 1);
 }
 
 TEST_P(PaintPropertyTreeBuilderTest,
@@ skipping 37 matching lines @@
   LayoutObject* b = document().getElementById("b")->layoutObject();
   const ObjectPaintProperties* bProperties = b->paintProperties();
   EXPECT_EQ(TransformationMatrix().translate3d(5, 7, 0),
             bProperties->transform()->matrix());
   // The paint offset transform should be snapped from (0.7,0.7) to (1,1).
   EXPECT_EQ(TransformationMatrix().translate(1, 1),
             bProperties->transform()->parent()->matrix());
   // The residual subpixel adjustment should be (0.7,0.7) - (1,1) = (-0.3,-0.3).
   LayoutPoint subpixelAccumulation =
       LayoutPoint(LayoutPoint(FloatPoint(0.7, 0.7)) - LayoutPoint(1, 1));
-  EXPECT_EQ(subpixelAccumulation,
-            bProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(subpixelAccumulation, b->paintOffset());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(LayoutUnit(5.7), LayoutUnit(7.7),
                                      LayoutUnit(40), LayoutUnit(40)),
                           b, frameView->layoutView());
 
   LayoutObject* c = document().getElementById("c")->layoutObject();
   const ObjectPaintProperties* cProperties = c->paintProperties();
   EXPECT_EQ(TransformationMatrix().translate3d(11, 13, 0),
             cProperties->transform()->matrix());
   // The paint offset should be (-0.3,-0.3) but the paint offset transform
   // should still be at (0,0) because it should be snapped.
   EXPECT_EQ(TransformationMatrix().translate(0, 0),
             cProperties->transform()->parent()->matrix());
   // The residual subpixel adjustment should still be (-0.3,-0.3).
-  EXPECT_EQ(subpixelAccumulation,
-            cProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(subpixelAccumulation, c->paintOffset());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(LayoutUnit(16.7), LayoutUnit(20.7),
                                      LayoutUnit(40), LayoutUnit(40)),
                           c, frameView->layoutView());
 
   // d should be painted starting at subpixelAccumulation + (0.7,0.7) =
   // (0.4,0.4).
   LayoutObject* d = document().getElementById("d")->layoutObject();
   LayoutPoint dPaintOffset =
       subpixelAccumulation + LayoutPoint(FloatPoint(0.7, 0.7));
-  const ObjectPaintProperties* dProperties = d->paintProperties();
-  EXPECT_EQ(dPaintOffset, dProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(dPaintOffset, d->paintOffset());
   // Visual rects via the non-paint properties system use enclosingIntRect
   // before applying transforms, because they are computed bottom-up and
   // therefore can't apply pixel snapping. Therefore apply a slop of 1px.
   CHECK_VISUAL_RECT(LayoutRect(LayoutUnit(16.7) + LayoutUnit(0.7),
                                LayoutUnit(20.7) + LayoutUnit(0.7),
                                LayoutUnit(40), LayoutUnit(40)),
                     d, frameView->layoutView(), 1);
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, PaintOffsetWithPixelSnappingWithFixedPos) {
@@ skipping 36 matching lines @@
   LayoutObject* b = document().getElementById("b")->layoutObject();
   const ObjectPaintProperties* bProperties = b->paintProperties();
   EXPECT_EQ(TransformationMatrix().translate(0, 0),
             bProperties->transform()->matrix());
   // The paint offset transform should be snapped from (0.7,0) to (1,0).
   EXPECT_EQ(TransformationMatrix().translate(1, 0),
             bProperties->transform()->parent()->matrix());
   // The residual subpixel adjustment should be (0.7,0) - (1,0) = (-0.3,0).
   LayoutPoint subpixelAccumulation =
       LayoutPoint(LayoutPoint(FloatPoint(0.7, 0)) - LayoutPoint(1, 0));
-  EXPECT_EQ(subpixelAccumulation,
-            bProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(subpixelAccumulation, b->paintOffset());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(LayoutUnit(0.7), LayoutUnit(0),
                                      LayoutUnit(40), LayoutUnit(40)),
                           b, frameView->layoutView());
 
   LayoutObject* fixed = document().getElementById("fixed")->layoutObject();
-  const ObjectPaintProperties* fixedProperties = fixed->paintProperties();
   // The residual subpixel adjustment should still be (-0.3,0).
-  EXPECT_EQ(subpixelAccumulation,
-            fixedProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(subpixelAccumulation, fixed->paintOffset());
   CHECK_EXACT_VISUAL_RECT(LayoutRect(LayoutUnit(0.7), LayoutUnit(0),
                                      LayoutUnit(40), LayoutUnit(40)),
                           fixed, frameView->layoutView());
 
   // d should be painted starting at subpixelAccumulation + (0.7,0) = (0.4,0).
   LayoutObject* d = document().getElementById("d")->layoutObject();
   LayoutPoint dPaintOffset =
       subpixelAccumulation + LayoutPoint(FloatPoint(0.7, 0));
-  const ObjectPaintProperties* dProperties = d->paintProperties();
-  EXPECT_EQ(dPaintOffset, dProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(dPaintOffset, d->paintOffset());
   // Visual rects via the non-paint properties system use enclosingIntRect
   // before applying transforms, because they are computed bottom-up and
   // therefore can't apply pixel snapping. Therefore apply a slop of 1px.
   CHECK_VISUAL_RECT(LayoutRect(LayoutUnit(0.7) + LayoutUnit(0.7), LayoutUnit(),
                                LayoutUnit(40), LayoutUnit(40)),
                     d, frameView->layoutView(), 1);
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, SvgPixelSnappingShouldResetPaintOffset) {
   setBodyInnerHTML(
       "<style>"
       "  #svg {"
       "    position: relative;"
       "    left: 0.1px;"
       "    transform: matrix(1, 0, 0, 1, 0, 0);"
       "  }"
       "</style>"
       "<svg id='svg'>"
       "    <rect id='rect' transform='translate(1, 1)'/>"
       "</svg>");
 
   LayoutObject& svgWithTransform =
       *document().getElementById("svg")->layoutObject();
   const ObjectPaintProperties* svgWithTransformProperties =
       svgWithTransform.paintProperties();
   EXPECT_EQ(TransformationMatrix(),
             svgWithTransformProperties->transform()->matrix());
-  EXPECT_EQ(
-      LayoutPoint(FloatPoint(0.1, 0)),
-      svgWithTransformProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(LayoutPoint(FloatPoint(0.1, 0)), svgWithTransform.paintOffset());
   EXPECT_EQ(nullptr,
             svgWithTransformProperties->svgLocalToBorderBoxTransform());
 
   LayoutObject& rectWithTransform =
       *document().getElementById("rect")->layoutObject();
   const ObjectPaintProperties* rectWithTransformProperties =
       rectWithTransform.paintProperties();
   EXPECT_EQ(TransformationMatrix().translate(1, 1),
             rectWithTransformProperties->transform()->matrix());
 
   // Ensure there is no PaintOffset transform between the rect and the svg's
   // transform.
   EXPECT_EQ(svgWithTransformProperties->transform(),
             rectWithTransformProperties->transform()->parent());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, SvgRootAndForeignObjectPixelSnapping) {
   setBodyInnerHTML(
       "<svg id=svg style='position: relative; left: 0.6px; top: 0.3px'>"
       "  <foreignObject id=foreign x='3.5' y='5.4' transform='translate(1, 1)'>"
       "    <div id=div style='position: absolute; left: 5.6px; top: 7.3px'>"
       "    </div>"
       "  </foreignObject>"
       "</svg>");
 
-  const auto* svgProperties =
-      getLayoutObjectByElementId("svg")->paintProperties();
+  const auto* svg = getLayoutObjectByElementId("svg");
+  const auto* svgProperties = svg->paintProperties();
   EXPECT_EQ(nullptr, svgProperties->paintOffsetTranslation());
-  EXPECT_EQ(LayoutPoint(LayoutUnit(8.6), LayoutUnit(8.3)),
-            svgProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(LayoutPoint(LayoutUnit(8.6), LayoutUnit(8.3)), svg->paintOffset());
   // Paint offset of SVGRoot is baked into svgLocalToBorderBoxTransform after
   // snapped to pixels.
   EXPECT_EQ(TransformationMatrix().translate(9, 8),
             svgProperties->svgLocalToBorderBoxTransform()->matrix());
 
-  const auto* foreignObjectProperties =
-      getLayoutObjectByElementId("foreign")->paintProperties();
+  const auto* foreignObject = getLayoutObjectByElementId("foreign");
+  const auto* foreignObjectProperties = foreignObject->paintProperties();
   EXPECT_EQ(nullptr, foreignObjectProperties->paintOffsetTranslation());
   // Paint offset of foreignObject should be originated from SVG root and
   // snapped to pixels.
-  EXPECT_EQ(LayoutPoint(4, 5),
-            foreignObjectProperties->localBorderBoxProperties()->paintOffset);
+  EXPECT_EQ(LayoutPoint(4, 5), foreignObject->paintOffset());
 
-  const auto* divProperties =
-      getLayoutObjectByElementId("div")->paintProperties();
+  const auto* div = getLayoutObjectByElementId("div");
   // Paint offset of descendant of foreignObject accumulates on paint offset of
   // foreignObject.
   EXPECT_EQ(LayoutPoint(LayoutUnit(4 + 5.6), LayoutUnit(5 + 7.3)),
-            divProperties->localBorderBoxProperties()->paintOffset);
+            div->paintOffset());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, NoRenderingContextByDefault) {
   setBodyInnerHTML("<div style='transform: translateZ(0)'></div>");
 
   const ObjectPaintProperties* properties =
       document().body()->firstChild()->layoutObject()->paintProperties();
   ASSERT_TRUE(properties->transform());
   EXPECT_FALSE(properties->transform()->hasRenderingContext());
 }
@@ skipping 368 matching lines @@
 
   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()
-                                       ->propertyTreeState.transform());
-  EXPECT_EQ(
-      frameContentClip(),
-      clipProperties->localBorderBoxProperties()->propertyTreeState.clip());
+  EXPECT_EQ(framePreTranslation(),
+            clipProperties->localBorderBoxProperties()->transform());
+  EXPECT_EQ(frameContentClip(),
+            clipProperties->localBorderBoxProperties()->clip());
 
   auto contentsProperties = clipProperties->contentsProperties();
-  EXPECT_EQ(LayoutPoint(30, 20), contentsProperties.paintOffset);
+  EXPECT_EQ(LayoutPoint(30, 20), clipper->paintOffset());
+  EXPECT_EQ(framePreTranslation(), contentsProperties.transform());
+  EXPECT_EQ(clipProperties->overflowClip(), contentsProperties.clip());
+
   EXPECT_EQ(framePreTranslation(),
-            contentsProperties.propertyTreeState.transform());
+            childProperties->localBorderBoxProperties()->transform());
   EXPECT_EQ(clipProperties->overflowClip(),
-            contentsProperties.propertyTreeState.clip());
+            childProperties->localBorderBoxProperties()->clip());
 
-  EXPECT_EQ(framePreTranslation(), childProperties->localBorderBoxProperties()
-                                       ->propertyTreeState.transform());
-  EXPECT_EQ(
-      clipProperties->overflowClip(),
-      childProperties->localBorderBoxProperties()->propertyTreeState.clip());
-
-  EXPECT_NE(
-      nullptr,
-      childProperties->localBorderBoxProperties()->propertyTreeState.effect());
+  EXPECT_NE(nullptr, childProperties->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()
-                                       ->propertyTreeState.transform());
-  EXPECT_EQ(
-      frameContentClip(),
-      clipProperties->localBorderBoxProperties()->propertyTreeState.clip());
+  EXPECT_EQ(framePreTranslation(),
+            clipProperties->localBorderBoxProperties()->transform());
+  EXPECT_EQ(frameContentClip(),
+            clipProperties->localBorderBoxProperties()->clip());
 
   auto contentsProperties = clipProperties->contentsProperties();
-  EXPECT_EQ(LayoutPoint(30, 20), contentsProperties.paintOffset);
+  EXPECT_EQ(LayoutPoint(30, 20), clipper->paintOffset());
+  EXPECT_EQ(framePreTranslation(), contentsProperties.transform());
+  EXPECT_EQ(clipProperties->overflowClip(), contentsProperties.clip());
+
   EXPECT_EQ(framePreTranslation(),
-            contentsProperties.propertyTreeState.transform());
+            childProperties->localBorderBoxProperties()->transform());
   EXPECT_EQ(clipProperties->overflowClip(),
-            contentsProperties.propertyTreeState.clip());
+            childProperties->localBorderBoxProperties()->clip());
 
-  EXPECT_EQ(framePreTranslation(), childProperties->localBorderBoxProperties()
-                                       ->propertyTreeState.transform());
-  EXPECT_EQ(
-      clipProperties->overflowClip(),
-      childProperties->localBorderBoxProperties()->propertyTreeState.clip());
-
-  EXPECT_NE(
-      nullptr,
-      childProperties->localBorderBoxProperties()->propertyTreeState.effect());
+  EXPECT_NE(nullptr, childProperties->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()
-                                          ->propertyTreeState.transform());
-  EXPECT_EQ(
-      frameContentClip(),
-      clipProperties->localBorderBoxProperties()->propertyTreeState.clip());
+  EXPECT_EQ(frameScrollTranslation(),
+            clipProperties->localBorderBoxProperties()->transform());
+  EXPECT_EQ(frameContentClip(),
+            clipProperties->localBorderBoxProperties()->clip());
 
   auto contentsProperties = clipProperties->contentsProperties();
-  EXPECT_EQ(LayoutPoint(30, 20), contentsProperties.paintOffset);
+  EXPECT_EQ(LayoutPoint(30, 20), clipper->paintOffset());
   EXPECT_EQ(clipProperties->scrollTranslation(),
-            contentsProperties.propertyTreeState.transform());
-  EXPECT_EQ(clipProperties->overflowClip(),
-            contentsProperties.propertyTreeState.clip());
+            contentsProperties.transform());
+  EXPECT_EQ(clipProperties->overflowClip(), contentsProperties.clip());
 
   EXPECT_EQ(clipProperties->scrollTranslation(),
-            childProperties->localBorderBoxProperties()
-                ->propertyTreeState.transform());
-  EXPECT_EQ(
-      clipProperties->overflowClip(),
-      childProperties->localBorderBoxProperties()->propertyTreeState.clip());
+            childProperties->localBorderBoxProperties()->transform());
+  EXPECT_EQ(clipProperties->overflowClip(),
+            childProperties->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 49 matching lines @@
       "</div>");
 
   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()
-                                       ->propertyTreeState.transform());
+  EXPECT_EQ(framePreTranslation(),
+            clipProperties->localBorderBoxProperties()->transform());
   // CSS clip on an element causes it to clip itself, not just descendants.
-  EXPECT_EQ(
-      clipProperties->cssClip(),
-      clipProperties->localBorderBoxProperties()->propertyTreeState.clip());
+  EXPECT_EQ(clipProperties->cssClip(),
+            clipProperties->localBorderBoxProperties()->clip());
 
   auto contentsProperties = clipProperties->contentsProperties();
-  EXPECT_EQ(LayoutPoint(30, 20), contentsProperties.paintOffset);
-  EXPECT_EQ(framePreTranslation(),
-            contentsProperties.propertyTreeState.transform());
-  EXPECT_EQ(clipProperties->cssClip(),
-            contentsProperties.propertyTreeState.clip());
+  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(),
-            svgWithViewBoxProperties->localBorderBoxProperties()
-                ->propertyTreeState.transform());
+            svgWithViewBoxProperties->localBorderBoxProperties()->transform());
 
   auto contentsProperties = svgWithViewBoxProperties->contentsProperties();
-  EXPECT_EQ(LayoutPoint(30, 20), contentsProperties.paintOffset);
-  EXPECT_EQ(framePreTranslation(),
-            contentsProperties.propertyTreeState.transform());
+  EXPECT_EQ(LayoutPoint(30, 20), svgWithViewBox.paintOffset());
+  EXPECT_EQ(framePreTranslation(), contentsProperties.transform());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, OverflowHiddenScrollProperties) {
   setBodyInnerHTML(
       "<style>"
       "  body {"
       "    margin: 0px;"
       "  }"
       "  #overflowHidden {"
       "    overflow: hidden;"
@@ skipping 331 matching lines @@
       "      <div id=top-left class=abs style='top: 0; left: 0'></div>"
       "      <div id=bottom-right class=abs style='bottom: 0; right: 0'></div>"
       "    </div>"
       "    <div id=space3 class=space></div>"
       "    <div id=space4 class=space></div>"
       "  </div>"
       "</div>");
 
   // Above the spanner.
   // Column 1.
-  EXPECT_EQ(LayoutPoint(), paintOffset(getLayoutObjectByElementId("space1")));
+  EXPECT_EQ(LayoutPoint(), getLayoutObjectByElementId("space1")->paintOffset());
   // Column 2. TODO(crbug.com/648274): This is incorrect. Should be (100, 0).
   EXPECT_EQ(LayoutPoint(0, 30),
-            paintOffset(getLayoutObjectByElementId("space2")));
+            getLayoutObjectByElementId("space2")->paintOffset());
 
   // The spanner's normal flow.
   EXPECT_EQ(LayoutPoint(0, 30),
-            paintOffset(getLayoutObjectByElementId("spanner")));
+            getLayoutObjectByElementId("spanner")->paintOffset());
   EXPECT_EQ(LayoutPoint(0, 30),
-            paintOffset(getLayoutObjectByElementId("normal")));
+            getLayoutObjectByElementId("normal")->paintOffset());
 
   // Below the spanner.
   // Column 1. TODO(crbug.com/648274): This is incorrect. Should be (0, 80).
   EXPECT_EQ(LayoutPoint(0, 60),
-            paintOffset(getLayoutObjectByElementId("space3")));
+            getLayoutObjectByElementId("space3")->paintOffset());
   // Column 2. TODO(crbug.com/648274): This is incorrect. Should be (100, 80).
   EXPECT_EQ(LayoutPoint(0, 90),
-            paintOffset(getLayoutObjectByElementId("space4")));
+            getLayoutObjectByElementId("space4")->paintOffset());
 
   // Out-of-flow positioned descendants of the spanner. They are laid out in
   // the relative-position container.
 
   // "top-left" should be aligned to the top-left corner of space1.
   EXPECT_EQ(LayoutPoint(0, 0),
-            paintOffset(getLayoutObjectByElementId("top-left")));
+            getLayoutObjectByElementId("top-left")->paintOffset());
 
   // "bottom-right" should be aligned to the bottom-right corner of space4.
   // TODO(crbug.com/648274): This is incorrect. Should be (180, 90).
   EXPECT_EQ(LayoutPoint(80, 100),
-            paintOffset(getLayoutObjectByElementId("bottom-right")));
+            getLayoutObjectByElementId("bottom-right")->paintOffset());
 }
 
 // Ensures no crash with multi-column containing relative-position inline with
 // spanner with absolute-position children.
 TEST_P(PaintPropertyTreeBuilderTest,
        MultiColumnInlineRelativeAndSpannerAndAbsPos) {
   setBodyInnerHTML(
       "<div style='columns:2; width: 200px; column-gap: 0'>"
       "  <span style='position: relative'>"
       "    <span id=spanner style='column-span: all'>"
@@ skipping 40 matching lines @@
   const ObjectPaintProperties* clipProperties =
       getLayoutObjectByElementId("clip")->paintProperties();
   const ObjectPaintProperties* filterProperties =
       getLayoutObjectByElementId("filter")->paintProperties();
   EXPECT_TRUE(filterProperties->effect()->parent()->isRoot());
   EXPECT_EQ(frameScrollTranslation(),
             filterProperties->effect()->localTransformSpace());
   EXPECT_EQ(clipProperties->overflowClip(),
             filterProperties->effect()->outputClip());
 
-  const ObjectPaintProperties* childProperties =
-      getLayoutObjectByElementId("child")->paintProperties();
   const PropertyTreeState& childPaintState =
-      childProperties->localBorderBoxProperties()->propertyTreeState;
+      *getLayoutObjectByElementId("child")
+           ->paintProperties()
+           ->localBorderBoxProperties();
 
   // This will change once we added clip expansion node.
   EXPECT_EQ(filterProperties->effect()->outputClip(), childPaintState.clip());
   EXPECT_EQ(filterProperties->effect(), childPaintState.effect());
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, TransformOriginWithAndWithoutTransform) {
   setBodyInnerHTML(
       "<style>"
       "  body { margin: 0 }"
@@ skipping 69 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()
-                ->propertyTreeState.clip());
+            descendant->paintProperties()->localBorderBoxProperties()->clip());
 
   toElement(ancestor->node())
       ->setAttribute(HTMLNames::styleAttr, "position: static");
   document().view()->updateAllLifecyclePhases();
   EXPECT_NE(ancestor->paintProperties()->overflowClip(),
-            descendant->paintProperties()
-                ->localBorderBoxProperties()
-                ->propertyTreeState.clip());
+            descendant->paintProperties()->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 16 matching lines @@
 }
 
 TEST_P(PaintPropertyTreeBuilderTest, EffectNodeAnimatedHasCompositorElementId) {
   loadTestData("opacity-animation.html");
   const ObjectPaintProperties* properties = paintPropertiesForElement("target");
   EXPECT_TRUE(properties->effect());
   EXPECT_NE(CompositorElementId(), properties->effect()->compositorElementId());
 }
 
 }  // namespace blink