[SPv2] Defer decision of raster invalidation after paint for changes z-index, transform, etc.

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"
@@ skipping 250 matching lines @@
     EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 6,
         TestDisplayItem(second, backgroundDrawingType),
         TestDisplayItem(second, foregroundDrawingType),
         TestDisplayItem(first, backgroundDrawingType),
         TestDisplayItem(first, foregroundDrawingType),
         TestDisplayItem(unaffected, backgroundDrawingType),
         TestDisplayItem(unaffected, foregroundDrawingType));
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
         EXPECT_EQ(1u, getPaintController().paintChunks().size());
-        // TODO(wangxianzhu): In real world we invalidate clients with reordered display items.
-        // Need to support raster invalidation for recordered display items without invalidating clients.
-        EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects, UnorderedElementsAre());
+        EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects, UnorderedElementsAre(
+            FloatRect(100, 100, 50, 200))); // Bounds of |second|.
     }
 }
 
 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())
@@ skipping 41 matching lines @@
         TestDisplayItem(first, backgroundDrawingType),
         TestDisplayItem(first, foregroundDrawingType),
         TestDisplayItem(unaffected, backgroundDrawingType),
         TestDisplayItem(unaffected, foregroundDrawingType));
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
         EXPECT_EQ(1u, getPaintController().paintChunks().size());
         EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects, UnorderedElementsAre(
             FloatRect(100, 100, 100, 100), // Old bounds of |first|.
             FloatRect(100, 100, 100, 100))); // New bounds of |first|.
+        // No need to invalidate raster of |second| because the client (|first|) which swapped order
+        // with it has been invalidated.
     }
 }
 
 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())
@@ skipping 347 matching lines @@
     if (!RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
         EXPECT_EQ(secondPicture, static_cast<const DrawingDisplayItem&>(getPaintController().getDisplayItemList()[1]).picture());
     EXPECT_TRUE(getPaintController().clientCacheIsValid(first));
     EXPECT_TRUE(getPaintController().clientCacheIsValid(second));
 
     getPaintController().invalidateAll();
     EXPECT_FALSE(getPaintController().clientCacheIsValid(first));
     EXPECT_FALSE(getPaintController().clientCacheIsValid(second));
 }
 
-TEST_P(PaintControllerTest, ComplexUpdateSwapOrder)
+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, PaintChunkProperties());
+
+    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));
+    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));
+    drawRect(context, container2, foregroundDrawingType, FloatRect(100, 200, 100, 100));
+    getPaintController().commitNewDisplayItems();
+
+    EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 8,
+        TestDisplayItem(container1, backgroundDrawingType),
+        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, PaintChunkProperties());
+
+    // Simulate the situation when container1 e.g. gets a z-index that is now greater than 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));
+    drawRect(context, container2, foregroundDrawingType, FloatRect(100, 200, 100, 100));
+    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));
+    getPaintController().commitNewDisplayItems();
+
+    EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 8,
+        TestDisplayItem(container2, backgroundDrawingType),
+        TestDisplayItem(content2, backgroundDrawingType),
+        TestDisplayItem(content2, foregroundDrawingType),
+        TestDisplayItem(container2, foregroundDrawingType),
+        TestDisplayItem(container1, backgroundDrawingType),
+        TestDisplayItem(content1, backgroundDrawingType),
+        TestDisplayItem(content1, foregroundDrawingType),
+        TestDisplayItem(container1, foregroundDrawingType));
+
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        EXPECT_EQ(1u, getPaintController().paintChunks().size());
+        EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects, UnorderedElementsAre(
+            FloatRect(100, 200, 100, 100), // Bounds of |container2| which was moved behind |container1|.
+            FloatRect(100, 200, 50, 200))); // Bounds of |content2| which was moved along with |container2|.
+    }
+}
+
+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, PaintChunkProperties());
 
     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 10 matching lines @@
         TestDisplayItem(container1, foregroundDrawingType),
         TestDisplayItem(container2, backgroundDrawingType),
         TestDisplayItem(content2, backgroundDrawingType),
         TestDisplayItem(content2, foregroundDrawingType),
         TestDisplayItem(container2, foregroundDrawingType));
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
         getPaintController().updateCurrentPaintChunkProperties(&m_rootPaintChunkId, PaintChunkProperties());
 
     // Simulate the situation when container1 e.g. gets a z-index that is now greater than 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, FloatRect(100, 200, 50, 200));
     drawRect(context, container2, foregroundDrawingType, FloatRect(100, 200, 100, 100));
     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));
     getPaintController().commitNewDisplayItems();
 
     EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 8,
         TestDisplayItem(container2, backgroundDrawingType),
         TestDisplayItem(content2, backgroundDrawingType),
         TestDisplayItem(content2, foregroundDrawingType),
         TestDisplayItem(container2, foregroundDrawingType),
         TestDisplayItem(container1, backgroundDrawingType),
         TestDisplayItem(content1, backgroundDrawingType),
         TestDisplayItem(content1, foregroundDrawingType),
         TestDisplayItem(container1, foregroundDrawingType));
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
         EXPECT_EQ(1u, getPaintController().paintChunks().size());
-        // TODO(wangxianzhu): In real world we invalidate clients with reordered display items.
-        // Need to support raster invalidation for recordered display items without invalidating clients.
         EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects, UnorderedElementsAre(
             FloatRect(100, 100, 100, 100), // Old bounds of |container1|.
-            FloatRect(100, 100, 100, 100))); // New bounds of |container1|.
+            FloatRect(100, 100, 100, 100), // New bounds of |container1|.
+            FloatRect(100, 200, 100, 100), // Bounds of |container2| which was moved behind |container1|.
+            FloatRect(100, 200, 50, 200))); // Bounds of |content2| which was moved along with |container2|.
     }
 }
 
 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());
@@ skipping 116 matching lines @@
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
         EXPECT_EQ(2u, getPaintController().paintChunks().size());
         EXPECT_EQ(PaintChunk::Id(container2, backgroundDrawingType), getPaintController().paintChunks()[0].id);
         EXPECT_EQ(PaintChunk::Id(container1, backgroundDrawingType), getPaintController().paintChunks()[1].id);
         // Swapping order of chunks should not invalidate anything.
         EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects, UnorderedElementsAre());
         EXPECT_THAT(getPaintController().paintChunks()[1].rasterInvalidationRects, UnorderedElementsAre());
     }
 }
 
+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;
+    PaintChunkProperties container2Properties;
+
+    {
+        if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+            PaintChunk::Id id(container1, backgroundDrawingType);
+            container1Properties.effect = EffectPaintPropertyNode::create(nullptr, 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(nullptr, 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();
+
+    EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 4,
+        TestDisplayItem(container1, backgroundDrawingType),
+        TestDisplayItem(content1, backgroundDrawingType),
+        TestDisplayItem(container2, backgroundDrawingType),
+        TestDisplayItem(content2, backgroundDrawingType));
+
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        EXPECT_EQ(2u, getPaintController().paintChunks().size());
+        EXPECT_EQ(PaintChunk::Id(container1, backgroundDrawingType), getPaintController().paintChunks()[0].id);
+        EXPECT_EQ(PaintChunk::Id(container2, backgroundDrawingType), getPaintController().paintChunks()[1].id);
+        EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects, UnorderedElementsAre(
+            FloatRect(LayoutRect::infiniteIntRect())));
+        EXPECT_THAT(getPaintController().paintChunks()[1].rasterInvalidationRects, UnorderedElementsAre(
+            FloatRect(LayoutRect::infiniteIntRect())));
+    }
+
+    // Move content2 into container1, without invalidation.
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        PaintChunk::Id id(container1, backgroundDrawingType);
+        getPaintController().updateCurrentPaintChunkProperties(&id, container1Properties);
+    }
+    drawRect(context, container1, backgroundDrawingType, FloatRect(100, 100, 100, 100));
+    drawRect(context, content1, backgroundDrawingType, FloatRect(100, 100, 50, 200));
+    drawRect(context, content2, backgroundDrawingType, FloatRect(100, 200, 50, 200));
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        PaintChunk::Id id(container2, backgroundDrawingType);
+        getPaintController().updateCurrentPaintChunkProperties(&id, container2Properties);
+    }
+    drawRect(context, container2, backgroundDrawingType, FloatRect(100, 200, 100, 100));
+
+    EXPECT_EQ(4, numCachedNewItems());
+#ifndef NDEBUG
+    EXPECT_EQ(3, numSequentialMatches());
+    EXPECT_EQ(1, numOutOfOrderMatches());
+    EXPECT_EQ(1, numIndexedItems());
+#endif
+
+    getPaintController().commitNewDisplayItems();
+
+    EXPECT_DISPLAY_LIST(getPaintController().getDisplayItemList(), 4,
+        TestDisplayItem(container1, backgroundDrawingType),
+        TestDisplayItem(content1, backgroundDrawingType),
+        TestDisplayItem(content2, backgroundDrawingType),
+        TestDisplayItem(container2, backgroundDrawingType));
+
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        EXPECT_EQ(2u, getPaintController().paintChunks().size());
+        EXPECT_EQ(PaintChunk::Id(container1, backgroundDrawingType), getPaintController().paintChunks()[0].id);
+        EXPECT_EQ(PaintChunk::Id(container2, backgroundDrawingType), getPaintController().paintChunks()[1].id);
+        // |content2| is invalidated raster on both the old chunk and the new chunk.
+        EXPECT_THAT(getPaintController().paintChunks()[0].rasterInvalidationRects, UnorderedElementsAre(
+            FloatRect(100, 200, 50, 200)));
+        EXPECT_THAT(getPaintController().paintChunks()[1].rasterInvalidationRects, UnorderedElementsAre(
+            FloatRect(100, 200, 50, 200)));
+    }
+}
+
 TEST_P(PaintControllerTest, OutOfOrderNoCrash)
 {
     FakeDisplayItemClient client("client");
     GraphicsContext context(getPaintController());
 
     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);
 
@@ skipping 838 matching lines @@
 }
 
 TEST_F(PaintControllerUnderInvalidationTest, FoldCompositingDrawingInSubsequence)
 {
     testFoldCompositingDrawingInSubsequence();
 }
 
 #endif // defined(GTEST_HAS_DEATH_TEST) && !OS(ANDROID)
 
 } // namespace blink