[SPv2] Add createOpacityOnlyEffect test helper

third_party/WebKit/Source/platform/graphics/paint/PaintControllerTest.cpp

 // Copyright 2014 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 "platform/graphics/paint/PaintController.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/paint/ClipPathDisplayItem.h"
 #include "platform/graphics/paint/ClipPathRecorder.h"
 #include "platform/graphics/paint/ClipRecorder.h"
 #include "platform/graphics/paint/CompositingRecorder.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 #include "platform/graphics/paint/SubsequenceRecorder.h"
 #include "platform/testing/FakeDisplayItemClient.h"
+#include "platform/testing/PaintPropertyTestHelpers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <memory>
 
+using blink::testing::createOpacityOnlyEffect;
+using blink::testing::defaultPaintChunkProperties;
 using testing::UnorderedElementsAre;
 
 namespace blink {
 
-class PaintControllerTestBase : public testing::Test {
+class PaintControllerTestBase : public ::testing::Test {
  public:
   PaintControllerTestBase() : m_paintController(PaintController::create()) {}
 
   IntRect visualRect(const PaintArtifact& paintArtifact, size_t index) {
     return paintArtifact.getDisplayItemList().visualRect(index);
   }
 
  protected:
   PaintController& getPaintController() { return *m_paintController; }
 
@@ skipping 11 matching lines @@
   int numIndexedItems() const { return m_paintController->m_numIndexedItems; }
 #endif
 
   void TearDown() override { m_featuresBackup.restore(); }
 
  private:
   std::unique_ptr<PaintController> m_paintController;
   RuntimeEnabledFeatures::Backup m_featuresBackup;
 };
 
-PaintChunkProperties rootPaintChunkProperties() {
-  PaintChunkProperties rootProperties;
-  rootProperties.transform = TransformPaintPropertyNode::root();
-  rootProperties.clip = ClipPaintPropertyNode::root();
-  rootProperties.effect = EffectPaintPropertyNode::root();
-  rootProperties.scroll = ScrollPaintPropertyNode::root();
-  return rootProperties;
-}
-
 const DisplayItem::Type foregroundDrawingType =
     static_cast<DisplayItem::Type>(DisplayItem::kDrawingPaintPhaseFirst + 4);
 const DisplayItem::Type backgroundDrawingType =
     DisplayItem::kDrawingPaintPhaseFirst;
 const DisplayItem::Type clipType = DisplayItem::kClipFirst;
 
 class TestDisplayItem final : public DisplayItem {
  public:
   TestDisplayItem(const FakeDisplayItemClient& client, Type type)
       : DisplayItem(client, type, sizeof(*this)) {}
@@ skipping 53 matching lines @@
   SPv1,
   SPv2,
   UnderInvalidationCheckingSPv1,
   UnderInvalidationCheckingSPv2,
 };
 
 // Tests using this class will be tested with under-invalidation-checking
 // enabled and disabled.
 class PaintControllerTest
     : public PaintControllerTestBase,
-      public testing::WithParamInterface<TestConfigurations> {
+      public ::testing::WithParamInterface<TestConfigurations> {
  public:
   PaintControllerTest()
       : m_rootPaintPropertyClient("root"),
         m_rootPaintChunkId(m_rootPaintPropertyClient,
                            DisplayItem::kUninitializedType) {}
 
  protected:
   void SetUp() override {
     switch (GetParam()) {
       case SPv1:
@@ skipping 20 matching lines @@
                         ::testing::Values(SPv1,
                                           SPv2,
                                           UnderInvalidationCheckingSPv1,
                                           UnderInvalidationCheckingSPv2));
 
 TEST_P(PaintControllerTest, NestedRecorders) {
   GraphicsContext context(getPaintController());
   FakeDisplayItemClient client("client", LayoutRect(100, 100, 200, 200));
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawClippedRect(context, client, clipType, backgroundDrawingType,
                   FloatRect(100, 100, 200, 200));
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(
       getPaintController().getDisplayItemList(), 3,
       TestDisplayItem(client, clipType),
       TestDisplayItem(client, backgroundDrawingType),
       TestDisplayItem(client, DisplayItem::clipTypeToEndClipType(clipType)));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     EXPECT_EQ(1u, getPaintController().paintChunks().size());
     EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects,
                 UnorderedElementsAre(FloatRect(LayoutRect::infiniteIntRect())));
   }
 }
 
 TEST_P(PaintControllerTest, UpdateBasic) {
   FakeDisplayItemClient first("first", LayoutRect(100, 100, 300, 300));
   FakeDisplayItemClient second("second", LayoutRect(100, 100, 200, 200));
   GraphicsContext context(getPaintController());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 300, 300));
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 200, 200));
   drawRect(context, first, foregroundDrawingType,
            FloatRect(100, 100, 300, 300));
 
   EXPECT_EQ(0, numCachedNewItems());
 
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 3,
                       TestDisplayItem(first, backgroundDrawingType),
                       TestDisplayItem(second, backgroundDrawingType),
                       TestDisplayItem(first, foregroundDrawingType));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     EXPECT_EQ(1u, getPaintController().paintChunks().size());
     EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects,
                 UnorderedElementsAre(FloatRect(LayoutRect::infiniteIntRect())));
 
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 300, 300));
   drawRect(context, first, foregroundDrawingType,
            FloatRect(100, 100, 300, 300));
 
   EXPECT_EQ(2, numCachedNewItems());
 #ifndef NDEBUG
   EXPECT_EQ(2, numSequentialMatches());
@@ skipping 16 matching lines @@
   }
 }
 
 TEST_P(PaintControllerTest, UpdateSwapOrder) {
   FakeDisplayItemClient first("first", LayoutRect(100, 100, 100, 100));
   FakeDisplayItemClient second("second", LayoutRect(100, 100, 50, 200));
   FakeDisplayItemClient unaffected("unaffected", LayoutRect(300, 300, 10, 10));
   GraphicsContext context(getPaintController());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, first, foregroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, second, foregroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, unaffected, backgroundDrawingType,
            FloatRect(300, 300, 10, 10));
   drawRect(context, unaffected, foregroundDrawingType,
            FloatRect(300, 300, 10, 10));
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 6,
                       TestDisplayItem(first, backgroundDrawingType),
                       TestDisplayItem(first, foregroundDrawingType),
                       TestDisplayItem(second, backgroundDrawingType),
                       TestDisplayItem(second, foregroundDrawingType),
                       TestDisplayItem(unaffected, backgroundDrawingType),
                       TestDisplayItem(unaffected, foregroundDrawingType));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, second, foregroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, first, foregroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, unaffected, backgroundDrawingType,
@@ skipping 26 matching lines @@
   }
 }
 
 TEST_P(PaintControllerTest, UpdateSwapOrderWithInvalidation) {
   FakeDisplayItemClient first("first", LayoutRect(100, 100, 100, 100));
   FakeDisplayItemClient second("second", LayoutRect(100, 100, 50, 200));
   FakeDisplayItemClient unaffected("unaffected", LayoutRect(300, 300, 10, 10));
   GraphicsContext context(getPaintController());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, first, foregroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, second, foregroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, unaffected, backgroundDrawingType,
            FloatRect(300, 300, 10, 10));
   drawRect(context, unaffected, foregroundDrawingType,
            FloatRect(300, 300, 10, 10));
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 6,
                       TestDisplayItem(first, backgroundDrawingType),
                       TestDisplayItem(first, foregroundDrawingType),
                       TestDisplayItem(second, backgroundDrawingType),
                       TestDisplayItem(second, foregroundDrawingType),
                       TestDisplayItem(unaffected, backgroundDrawingType),
                       TestDisplayItem(unaffected, foregroundDrawingType));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   first.setDisplayItemsUncached();
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, second, foregroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, first, foregroundDrawingType,
@@ skipping 31 matching lines @@
   }
 }
 
 TEST_P(PaintControllerTest, UpdateNewItemInMiddle) {
   FakeDisplayItemClient first("first", LayoutRect(100, 100, 100, 100));
   FakeDisplayItemClient second("second", LayoutRect(100, 100, 50, 200));
   FakeDisplayItemClient third("third", LayoutRect(125, 100, 200, 50));
   GraphicsContext context(getPaintController());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 50, 200));
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 2,
                       TestDisplayItem(first, backgroundDrawingType),
                       TestDisplayItem(second, backgroundDrawingType));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, third, backgroundDrawingType, FloatRect(125, 100, 200, 50));
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 50, 200));
 
   EXPECT_EQ(2, numCachedNewItems());
 #ifndef NDEBUG
@@ skipping 18 matching lines @@
   }
 }
 
 TEST_P(PaintControllerTest, UpdateInvalidationWithPhases) {
   FakeDisplayItemClient first("first", LayoutRect(100, 100, 100, 100));
   FakeDisplayItemClient second("second", LayoutRect(100, 100, 50, 200));
   FakeDisplayItemClient third("third", LayoutRect(300, 100, 50, 50));
   GraphicsContext context(getPaintController());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, third, backgroundDrawingType, FloatRect(300, 100, 50, 50));
   drawRect(context, first, foregroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, second, foregroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, third, foregroundDrawingType, FloatRect(300, 100, 50, 50));
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 6,
                       TestDisplayItem(first, backgroundDrawingType),
                       TestDisplayItem(second, backgroundDrawingType),
                       TestDisplayItem(third, backgroundDrawingType),
                       TestDisplayItem(first, foregroundDrawingType),
                       TestDisplayItem(second, foregroundDrawingType),
                       TestDisplayItem(third, foregroundDrawingType));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   second.setDisplayItemsUncached();
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, third, backgroundDrawingType, FloatRect(300, 100, 50, 50));
   drawRect(context, first, foregroundDrawingType,
            FloatRect(100, 100, 100, 100));
@@ skipping 26 matching lines @@
                     FloatRect(100, 100, 50, 200)));  // New bounds of |second|.
   }
 }
 
 TEST_P(PaintControllerTest, UpdateAddFirstOverlap) {
   FakeDisplayItemClient first("first", LayoutRect(100, 100, 150, 150));
   FakeDisplayItemClient second("second", LayoutRect(200, 200, 50, 50));
   GraphicsContext context(getPaintController());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, second, backgroundDrawingType, FloatRect(200, 200, 50, 50));
   drawRect(context, second, foregroundDrawingType, FloatRect(200, 200, 50, 50));
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 2,
                       TestDisplayItem(second, backgroundDrawingType),
                       TestDisplayItem(second, foregroundDrawingType));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   first.setDisplayItemsUncached();
   second.setDisplayItemsUncached();
   second.setVisualRect(LayoutRect(150, 150, 100, 100));
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 150, 150));
   drawRect(context, first, foregroundDrawingType,
            FloatRect(100, 100, 150, 150));
   drawRect(context, second, backgroundDrawingType,
@@ skipping 12 matching lines @@
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     EXPECT_EQ(1u, getPaintController().paintChunks().size());
     EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects,
                 UnorderedElementsAre(
                     FloatRect(100, 100, 150,
                               150),  // |first| newly appeared in the chunk.
                     FloatRect(200, 200, 50, 50),      // Old bounds of |second|.
                     FloatRect(150, 150, 100, 100)));  // New bounds of |second|.
 
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, second, backgroundDrawingType,
            FloatRect(150, 150, 100, 100));
   drawRect(context, second, foregroundDrawingType,
            FloatRect(150, 150, 100, 100));
 
   EXPECT_EQ(2, numCachedNewItems());
 #ifndef NDEBUG
   EXPECT_EQ(2, numSequentialMatches());
@@ skipping 15 matching lines @@
             100, 100, 150, 150)));  // |first| disappeared from the chunk.
   }
 }
 
 TEST_P(PaintControllerTest, UpdateAddLastOverlap) {
   FakeDisplayItemClient first("first", LayoutRect(100, 100, 150, 150));
   FakeDisplayItemClient second("second", LayoutRect(200, 200, 50, 50));
   GraphicsContext context(getPaintController());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 150, 150));
   drawRect(context, first, foregroundDrawingType,
            FloatRect(100, 100, 150, 150));
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 2,
                       TestDisplayItem(first, backgroundDrawingType),
                       TestDisplayItem(first, foregroundDrawingType));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   first.setDisplayItemsUncached();
   first.setVisualRect(LayoutRect(150, 150, 100, 100));
   second.setDisplayItemsUncached();
   drawRect(context, first, backgroundDrawingType,
            FloatRect(150, 150, 100, 100));
   drawRect(context, first, foregroundDrawingType,
            FloatRect(150, 150, 100, 100));
   drawRect(context, second, backgroundDrawingType, FloatRect(200, 200, 50, 50));
@@ skipping 10 matching lines @@
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     EXPECT_EQ(1u, getPaintController().paintChunks().size());
     EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects,
                 UnorderedElementsAre(
                     FloatRect(100, 100, 150, 150),  // Old bounds of |first|.
                     FloatRect(150, 150, 100, 100),  // New bounds of |first|.
                     FloatRect(200, 200, 50,
                               50)));  // |second| newly appeared in the chunk.
 
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   first.setDisplayItemsUncached();
   first.setVisualRect(LayoutRect(100, 100, 150, 150));
   second.setDisplayItemsUncached();
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 150, 150));
   drawRect(context, first, foregroundDrawingType,
            FloatRect(100, 100, 150, 150));
   EXPECT_EQ(0, numCachedNewItems());
@@ skipping 15 matching lines @@
 }
 
 TEST_P(PaintControllerTest, UpdateClip) {
   FakeDisplayItemClient first("first", LayoutRect(100, 100, 150, 150));
   FakeDisplayItemClient second("second", LayoutRect(100, 100, 200, 200));
   GraphicsContext context(getPaintController());
 
   {
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       PaintChunk::Id id(first, clipType);
-      PaintChunkProperties properties = rootPaintChunkProperties();
+      PaintChunkProperties properties = defaultPaintChunkProperties();
       properties.clip = ClipPaintPropertyNode::create(
           nullptr, nullptr, FloatRoundedRect(1, 1, 2, 2));
       getPaintController().updateCurrentPaintChunkProperties(&id, properties);
     }
     ClipRecorder clipRecorder(context, first, clipType, IntRect(1, 1, 2, 2));
     drawRect(context, first, backgroundDrawingType,
              FloatRect(100, 100, 150, 150));
     drawRect(context, second, backgroundDrawingType,
              FloatRect(100, 100, 200, 200));
   }
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(
       getPaintController().getDisplayItemList(), 4,
       TestDisplayItem(first, clipType),
       TestDisplayItem(first, backgroundDrawingType),
       TestDisplayItem(second, backgroundDrawingType),
       TestDisplayItem(first, DisplayItem::clipTypeToEndClipType(clipType)));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   first.setDisplayItemsUncached();
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 150, 150));
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 200, 200));
 
   EXPECT_EQ(1, numCachedNewItems());
 #ifndef NDEBUG
   EXPECT_EQ(1, numSequentialMatches());
   EXPECT_EQ(0, numOutOfOrderMatches());
   EXPECT_EQ(1, numIndexedItems());
 #endif
 
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 2,
                       TestDisplayItem(first, backgroundDrawingType),
                       TestDisplayItem(second, backgroundDrawingType));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     EXPECT_EQ(1u, getPaintController().paintChunks().size());
     EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects,
                 UnorderedElementsAre(FloatRect(
                     LayoutRect::infiniteIntRect())));  // This is a new chunk.
 
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   second.setDisplayItemsUncached();
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 150, 150));
   {
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       PaintChunk::Id id(second, clipType);
-      PaintChunkProperties properties = rootPaintChunkProperties();
+      PaintChunkProperties properties = defaultPaintChunkProperties();
       properties.clip = ClipPaintPropertyNode::create(
           nullptr, nullptr, FloatRoundedRect(1, 1, 2, 2));
       getPaintController().updateCurrentPaintChunkProperties(&id, properties);
     }
     ClipRecorder clipRecorder(context, second, clipType, IntRect(1, 1, 2, 2));
     drawRect(context, second, backgroundDrawingType,
              FloatRect(100, 100, 200, 200));
   }
   getPaintController().commitNewDisplayItems();
 
@@ skipping 15 matching lines @@
                     LayoutRect::infiniteIntRect())));  // This is a new chunk.
   }
 }
 
 TEST_P(PaintControllerTest, CachedDisplayItems) {
   FakeDisplayItemClient first("first");
   FakeDisplayItemClient second("second");
   GraphicsContext context(getPaintController());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 150, 150));
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 150, 150));
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 2,
                       TestDisplayItem(first, backgroundDrawingType),
                       TestDisplayItem(second, backgroundDrawingType));
   EXPECT_TRUE(getPaintController().clientCacheIsValid(first));
   EXPECT_TRUE(getPaintController().clientCacheIsValid(second));
   const SkPicture* firstPicture =
       static_cast<const DrawingDisplayItem&>(
           getPaintController().getDisplayItemList()[0])
           .picture();
   const SkPicture* secondPicture =
       static_cast<const DrawingDisplayItem&>(
           getPaintController().getDisplayItemList()[1])
           .picture();
 
   first.setDisplayItemsUncached();
   EXPECT_FALSE(getPaintController().clientCacheIsValid(first));
   EXPECT_TRUE(getPaintController().clientCacheIsValid(second));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
   drawRect(context, first, backgroundDrawingType,
            FloatRect(100, 100, 150, 150));
   drawRect(context, second, backgroundDrawingType,
            FloatRect(100, 100, 150, 150));
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 2,
                       TestDisplayItem(first, backgroundDrawingType),
                       TestDisplayItem(second, backgroundDrawingType));
@@ skipping 17 matching lines @@
 TEST_P(PaintControllerTest, UpdateSwapOrderWithChildren) {
   FakeDisplayItemClient container1("container1",
                                    LayoutRect(100, 100, 100, 100));
   FakeDisplayItemClient content1("content1", LayoutRect(100, 100, 50, 200));
   FakeDisplayItemClient container2("container2",
                                    LayoutRect(100, 200, 100, 100));
   FakeDisplayItemClient content2("content2", LayoutRect(100, 200, 50, 200));
   GraphicsContext context(getPaintController());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, container1, backgroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, content1, backgroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, content1, foregroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, container1, foregroundDrawingType,
            FloatRect(100, 100, 100, 100));
@@ skipping 12 matching lines @@
                       TestDisplayItem(content1, backgroundDrawingType),
                       TestDisplayItem(content1, foregroundDrawingType),
                       TestDisplayItem(container1, foregroundDrawingType),
                       TestDisplayItem(container2, backgroundDrawingType),
                       TestDisplayItem(content2, backgroundDrawingType),
                       TestDisplayItem(content2, foregroundDrawingType),
                       TestDisplayItem(container2, foregroundDrawingType));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   // Simulate the situation when |container1| gets a z-index that is greater
   // than that of |container2|.
   drawRect(context, container2, backgroundDrawingType,
            FloatRect(100, 200, 100, 100));
   drawRect(context, content2, backgroundDrawingType,
            FloatRect(100, 200, 50, 200));
   drawRect(context, content2, foregroundDrawingType,
            FloatRect(100, 200, 50, 200));
@@ skipping 34 matching lines @@
 TEST_P(PaintControllerTest, UpdateSwapOrderWithChildrenAndInvalidation) {
   FakeDisplayItemClient container1("container1",
                                    LayoutRect(100, 100, 100, 100));
   FakeDisplayItemClient content1("content1", LayoutRect(100, 100, 50, 200));
   FakeDisplayItemClient container2("container2",
                                    LayoutRect(100, 200, 100, 100));
   FakeDisplayItemClient content2("content2", LayoutRect(100, 200, 50, 200));
   GraphicsContext context(getPaintController());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   drawRect(context, container1, backgroundDrawingType,
            FloatRect(100, 100, 100, 100));
   drawRect(context, content1, backgroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, content1, foregroundDrawingType,
            FloatRect(100, 100, 50, 200));
   drawRect(context, container1, foregroundDrawingType,
            FloatRect(100, 100, 100, 100));
@@ skipping 12 matching lines @@
                       TestDisplayItem(content1, backgroundDrawingType),
                       TestDisplayItem(content1, foregroundDrawingType),
                       TestDisplayItem(container1, foregroundDrawingType),
                       TestDisplayItem(container2, backgroundDrawingType),
                       TestDisplayItem(content2, backgroundDrawingType),
                       TestDisplayItem(content2, foregroundDrawingType),
                       TestDisplayItem(container2, foregroundDrawingType));
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   // Simulate the situation when |container1| gets a z-index that is greater
   // than that of |container2|, and |container1| is invalidated.
   container1.setDisplayItemsUncached();
   drawRect(context, container2, backgroundDrawingType,
            FloatRect(100, 200, 100, 100));
   drawRect(context, content2, backgroundDrawingType,
            FloatRect(100, 200, 50, 200));
   drawRect(context, content2, foregroundDrawingType,
@@ skipping 36 matching lines @@
 
 TEST_P(PaintControllerTest, CachedSubsequenceSwapOrder) {
   FakeDisplayItemClient container1("container1",
                                    LayoutRect(100, 100, 100, 100));
   FakeDisplayItemClient content1("content1", LayoutRect(100, 100, 50, 200));
   FakeDisplayItemClient container2("container2",
                                    LayoutRect(100, 200, 100, 100));
   FakeDisplayItemClient content2("content2", LayoutRect(100, 200, 50, 200));
   GraphicsContext context(getPaintController());
 
-  PaintChunkProperties container1Properties = rootPaintChunkProperties();
-  PaintChunkProperties container2Properties = rootPaintChunkProperties();
+  PaintChunkProperties container1Properties = defaultPaintChunkProperties();
+  PaintChunkProperties container2Properties = defaultPaintChunkProperties();
 
   {
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       PaintChunk::Id id(container1, backgroundDrawingType);
-      container1Properties.effect = EffectPaintPropertyNode::create(
-          EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
-          ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.5);
+      container1Properties.effect =
+          createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.5);
       getPaintController().updateCurrentPaintChunkProperties(
           &id, container1Properties);
     }
     SubsequenceRecorder r(context, container1);
     drawRect(context, container1, backgroundDrawingType,
              FloatRect(100, 100, 100, 100));
     drawRect(context, content1, backgroundDrawingType,
              FloatRect(100, 100, 50, 200));
     drawRect(context, content1, foregroundDrawingType,
              FloatRect(100, 100, 50, 200));
     drawRect(context, container1, foregroundDrawingType,
              FloatRect(100, 100, 100, 100));
   }
   {
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       PaintChunk::Id id(container2, backgroundDrawingType);
-      container2Properties.effect = EffectPaintPropertyNode::create(
-          EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
-          ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.5);
+      container2Properties.effect =
+          createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.5);
       getPaintController().updateCurrentPaintChunkProperties(
           &id, container2Properties);
     }
     SubsequenceRecorder r(context, container2);
     drawRect(context, container2, backgroundDrawingType,
              FloatRect(100, 200, 100, 100));
     drawRect(context, content2, backgroundDrawingType,
              FloatRect(100, 200, 50, 200));
     drawRect(context, content2, foregroundDrawingType,
              FloatRect(100, 200, 50, 200));
@@ skipping 124 matching lines @@
 
 TEST_P(PaintControllerTest, UpdateSwapOrderCrossingChunks) {
   FakeDisplayItemClient container1("container1",
                                    LayoutRect(100, 100, 100, 100));
   FakeDisplayItemClient content1("content1", LayoutRect(100, 100, 50, 200));
   FakeDisplayItemClient container2("container2",
                                    LayoutRect(100, 200, 100, 100));
   FakeDisplayItemClient content2("content2", LayoutRect(100, 200, 50, 200));
   GraphicsContext context(getPaintController());
 
-  PaintChunkProperties container1Properties = rootPaintChunkProperties();
-  PaintChunkProperties container2Properties = rootPaintChunkProperties();
+  PaintChunkProperties container1Properties = defaultPaintChunkProperties();
+  PaintChunkProperties container2Properties = defaultPaintChunkProperties();
 
   {
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       PaintChunk::Id id(container1, backgroundDrawingType);
-      container1Properties.effect = EffectPaintPropertyNode::create(
-          EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
-          ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.5);
+      container1Properties.effect =
+          createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.5);
       getPaintController().updateCurrentPaintChunkProperties(
           &id, container1Properties);
     }
     drawRect(context, container1, backgroundDrawingType,
              FloatRect(100, 100, 100, 100));
     drawRect(context, content1, backgroundDrawingType,
              FloatRect(100, 100, 50, 200));
   }
   {
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       PaintChunk::Id id(container2, backgroundDrawingType);
-      container2Properties.effect = EffectPaintPropertyNode::create(
-          EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
-          ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.5);
+      container2Properties.effect =
+          createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.5);
       getPaintController().updateCurrentPaintChunkProperties(
           &id, container2Properties);
     }
     drawRect(context, container2, backgroundDrawingType,
              FloatRect(100, 200, 100, 100));
     drawRect(context, content2, backgroundDrawingType,
              FloatRect(100, 200, 50, 200));
   }
   getPaintController().commitNewDisplayItems();
 
@@ skipping 71 matching lines @@
   const DisplayItem::Type type1 = DisplayItem::kDrawingFirst;
   const DisplayItem::Type type2 =
       static_cast<DisplayItem::Type>(DisplayItem::kDrawingFirst + 1);
   const DisplayItem::Type type3 =
       static_cast<DisplayItem::Type>(DisplayItem::kDrawingFirst + 2);
   const DisplayItem::Type type4 =
       static_cast<DisplayItem::Type>(DisplayItem::kDrawingFirst + 3);
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
   drawRect(context, client, type1, FloatRect(100, 100, 100, 100));
   drawRect(context, client, type2, FloatRect(100, 100, 50, 200));
   drawRect(context, client, type3, FloatRect(100, 100, 50, 200));
   drawRect(context, client, type4, FloatRect(100, 100, 100, 100));
 
   getPaintController().commitNewDisplayItems();
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
   drawRect(context, client, type2, FloatRect(100, 100, 50, 200));
   drawRect(context, client, type3, FloatRect(100, 100, 50, 200));
   drawRect(context, client, type1, FloatRect(100, 100, 100, 100));
   drawRect(context, client, type4, FloatRect(100, 100, 100, 100));
 
   getPaintController().commitNewDisplayItems();
 }
 
 TEST_P(PaintControllerTest, CachedNestedSubsequenceUpdate) {
   FakeDisplayItemClient container1("container1",
                                    LayoutRect(100, 100, 100, 100));
   FakeDisplayItemClient content1("content1", LayoutRect(100, 100, 50, 200));
   FakeDisplayItemClient container2("container2",
                                    LayoutRect(100, 200, 100, 100));
   FakeDisplayItemClient content2("content2", LayoutRect(100, 200, 50, 200));
   GraphicsContext context(getPaintController());
 
   PaintChunkProperties container1BackgroundProperties =
-      rootPaintChunkProperties();
-  PaintChunkProperties content1Properties = rootPaintChunkProperties();
+      defaultPaintChunkProperties();
+  PaintChunkProperties content1Properties = defaultPaintChunkProperties();
   PaintChunkProperties container1ForegroundProperties =
-      rootPaintChunkProperties();
+      defaultPaintChunkProperties();
   PaintChunkProperties container2BackgroundProperties =
-      rootPaintChunkProperties();
-  PaintChunkProperties content2Properties = rootPaintChunkProperties();
+      defaultPaintChunkProperties();
+  PaintChunkProperties content2Properties = defaultPaintChunkProperties();
 
   {
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       PaintChunk::Id id(container1, backgroundDrawingType);
-      container1BackgroundProperties.effect = EffectPaintPropertyNode::create(
-          EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
-          ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.5);
+      container1BackgroundProperties.effect =
+          createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.5);
       getPaintController().updateCurrentPaintChunkProperties(
           &id, container1BackgroundProperties);
     }
     SubsequenceRecorder r(context, container1);
     drawRect(context, container1, backgroundDrawingType,
              FloatRect(100, 100, 100, 100));
     {
       if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
         PaintChunk::Id id(content1, backgroundDrawingType);
-        content1Properties.effect = EffectPaintPropertyNode::create(
-            EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
-            ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.6);
+        content1Properties.effect =
+            createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.6);
         getPaintController().updateCurrentPaintChunkProperties(
             &id, content1Properties);
       }
       SubsequenceRecorder r(context, content1);
       drawRect(context, content1, backgroundDrawingType,
                FloatRect(100, 100, 50, 200));
       drawRect(context, content1, foregroundDrawingType,
                FloatRect(100, 100, 50, 200));
     }
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       PaintChunk::Id id(container1, foregroundDrawingType);
-      container1ForegroundProperties.effect = EffectPaintPropertyNode::create(
-          EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
-          ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.5);
+      container1ForegroundProperties.effect =
+          createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.5);
       getPaintController().updateCurrentPaintChunkProperties(
           &id, container1ForegroundProperties);
     }
     drawRect(context, container1, foregroundDrawingType,
              FloatRect(100, 100, 100, 100));
   }
   {
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       PaintChunk::Id id(container2, backgroundDrawingType);
-      container2BackgroundProperties.effect = EffectPaintPropertyNode::create(
-          EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
-          ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.7);
+      container2BackgroundProperties.effect =
+          createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.7);
       getPaintController().updateCurrentPaintChunkProperties(
           &id, container2BackgroundProperties);
     }
     SubsequenceRecorder r(context, container2);
     drawRect(context, container2, backgroundDrawingType,
              FloatRect(100, 200, 100, 100));
     {
       if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
         PaintChunk::Id id(content2, backgroundDrawingType);
-        content2Properties.effect = EffectPaintPropertyNode::create(
-            EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
-            ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.8);
+        content2Properties.effect =
+            createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.8);
         getPaintController().updateCurrentPaintChunkProperties(
             &id, content2Properties);
       }
       SubsequenceRecorder r(context, content2);
       drawRect(context, content2, backgroundDrawingType,
                FloatRect(100, 200, 50, 200));
     }
   }
   getPaintController().commitNewDisplayItems();
 
@@ skipping 146 matching lines @@
   DisplayItemClient::endShouldKeepAliveAllClients();
 #endif
 }
 
 TEST_P(PaintControllerTest, SkipCache) {
   FakeDisplayItemClient multicol("multicol", LayoutRect(100, 100, 200, 200));
   FakeDisplayItemClient content("content", LayoutRect(100, 100, 100, 100));
   GraphicsContext context(getPaintController());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   FloatRect rect1(100, 100, 50, 50);
   FloatRect rect2(150, 100, 50, 50);
   FloatRect rect3(200, 100, 50, 50);
 
   drawRect(context, multicol, backgroundDrawingType,
            FloatRect(100, 200, 100, 100));
 
   getPaintController().beginSkippingCache();
@@ skipping 16 matching lines @@
                     getPaintController().getDisplayItemList()[2])
                     .picture());
   EXPECT_NE(picture1, picture2);
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     EXPECT_EQ(1u, getPaintController().paintChunks().size());
     EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects,
                 UnorderedElementsAre(FloatRect(LayoutRect::infiniteIntRect())));
 
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   // Draw again with nothing invalidated.
   EXPECT_TRUE(getPaintController().clientCacheIsValid(multicol));
   drawRect(context, multicol, backgroundDrawingType,
            FloatRect(100, 200, 100, 100));
 
   getPaintController().beginSkippingCache();
   drawRect(context, content, foregroundDrawingType, rect1);
   drawRect(context, content, foregroundDrawingType, rect2);
@@ skipping 21 matching lines @@
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     EXPECT_EQ(1u, getPaintController().paintChunks().size());
     EXPECT_THAT(
         getPaintController().paintChunks()[0].rasterInvalidationRects,
         UnorderedElementsAre(
             FloatRect(100, 100, 100, 100),    // Old bounds of |content|.
             FloatRect(100, 100, 100, 100)));  // New bounds of |content|.
 
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
 
   // Now the multicol becomes 3 columns and repaints.
   multicol.setDisplayItemsUncached();
   drawRect(context, multicol, backgroundDrawingType,
            FloatRect(100, 100, 100, 100));
 
   getPaintController().beginSkippingCache();
   drawRect(context, content, foregroundDrawingType, rect1);
   drawRect(context, content, foregroundDrawingType, rect2);
@@ skipping 30 matching lines @@
 TEST_P(PaintControllerTest, PartialSkipCache) {
   FakeDisplayItemClient content("content");
   GraphicsContext context(getPaintController());
 
   FloatRect rect1(100, 100, 50, 50);
   FloatRect rect2(150, 100, 50, 50);
   FloatRect rect3(200, 100, 50, 50);
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
   drawRect(context, content, backgroundDrawingType, rect1);
   getPaintController().beginSkippingCache();
   drawRect(context, content, foregroundDrawingType, rect2);
   getPaintController().endSkippingCache();
   drawRect(context, content, foregroundDrawingType, rect3);
 
   getPaintController().commitNewDisplayItems();
 
   EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 3,
@@ skipping 13 matching lines @@
                     getPaintController().getDisplayItemList()[2])
                     .picture());
   EXPECT_NE(picture1, picture2);
 
   // Content's cache is invalid because it has display items skipped cache.
   EXPECT_FALSE(getPaintController().clientCacheIsValid(content));
   EXPECT_EQ(PaintInvalidationFull, content.getPaintInvalidationReason());
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        &m_rootPaintChunkId, rootPaintChunkProperties());
+        &m_rootPaintChunkId, defaultPaintChunkProperties());
   }
   // Draw again with nothing invalidated.
   drawRect(context, content, backgroundDrawingType, rect1);
   getPaintController().beginSkippingCache();
   drawRect(context, content, foregroundDrawingType, rect2);
   getPaintController().endSkippingCache();
   drawRect(context, content, foregroundDrawingType, rect3);
 
   EXPECT_EQ(0, numCachedNewItems());
 #ifndef NDEBUG
@@ skipping 70 matching lines @@
                       TestDisplayItem(first, backgroundDrawingType),
                       TestDisplayItem(third, backgroundDrawingType));
 }
 
 TEST_F(PaintControllerTestBase, SmallPaintControllerHasOnePaintChunk) {
   RuntimeEnabledFeatures::setSlimmingPaintV2Enabled(true);
   FakeDisplayItemClient client("test client");
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     getPaintController().updateCurrentPaintChunkProperties(
-        nullptr, rootPaintChunkProperties());
+        nullptr, defaultPaintChunkProperties());
   }
   GraphicsContext context(getPaintController());
   drawRect(context, client, backgroundDrawingType, FloatRect(0, 0, 100, 100));
 
   getPaintController().commitNewDisplayItems();
   const auto& paintChunks = getPaintController().paintChunks();
   ASSERT_EQ(1u, paintChunks.size());
   EXPECT_EQ(0u, paintChunks[0].beginIndex);
   EXPECT_EQ(1u, paintChunks[0].endIndex);
 }
@@ skipping 462 matching lines @@
 }
 
 TEST_F(PaintControllerUnderInvalidationTest,
        FoldCompositingDrawingInSubsequence) {
   testFoldCompositingDrawingInSubsequence();
 }
 
 #endif  // defined(GTEST_HAS_DEATH_TEST) && !OS(ANDROID)
 
 }  // namespace blink