First version of new merge algorithm (not enabled yet)

Source/core/paint/ViewDisplayListTest.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 "config.h"
 
 #include "core/layout/compositing/RenderLayerCompositor.h"
+#include "core/page/FocusController.h"
 #include "core/paint/LayerClipRecorder.h"
 #include "core/paint/LayerPainter.h"
 #include "core/paint/RenderDrawingRecorder.h"
+#include "core/paint/SubtreeInfoRecorder.h"
 #include "core/rendering/InlineTextBox.h"
 #include "core/rendering/RenderText.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/RenderingTestHelper.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include <gtest/gtest.h>
 
 namespace blink {
-namespace {
 
 class ViewDisplayListTest : public RenderingTest {
 public:
     ViewDisplayListTest() : m_renderView(nullptr) { }
 
 protected:
     RenderView* renderView() { return m_renderView; }
     DisplayItemList& rootDisplayItemList() { return *renderView()->layer()->graphicsLayerBacking()->displayItemList(); }
+    const Vector<OwnPtr<DisplayItem>>& newPaintListBeforeUpdate() { return rootDisplayItemList().m_newPaints; }
 
 private:
     virtual void SetUp() override
     {
         RuntimeEnabledFeatures::setSlimmingPaintEnabled(true);
 
         RenderingTest::SetUp();
         enableCompositing();
 
         m_renderView = document().view()->renderView();
@@ skipping 12 matching lines @@
 class TestDisplayItem : public DisplayItem {
 public:
     TestDisplayItem(const RenderObject* renderer, Type type) : DisplayItem(renderer->displayItemClient(), type) { }
     TestDisplayItem(DisplayItemClient displayItemClient, Type type) : DisplayItem(displayItemClient, type) { }
 
     virtual void replay(GraphicsContext*) override final { ASSERT_NOT_REACHED(); }
     virtual void appendToWebDisplayItemList(WebDisplayItemList*) const override final { ASSERT_NOT_REACHED(); }
 };
 
 #ifndef NDEBUG
-#define TRACE_DISPLAY_ITEMS(expected, actual) \
-    String trace = "Expected: " + (expected).asDebugString() + " Actual: " + (actual).asDebugString(); \
+#define TRACE_DISPLAY_ITEMS(i, expected, actual) \
+    String trace = String::format("%d: ", (int)i) + "Expected: " + (expected).asDebugString() + " Actual: " + (actual).asDebugString(); \
     SCOPED_TRACE(trace.utf8().data());
 #else
-#define TRACE_DISPLAY_ITEMS(expected, actual)
+#define TRACE_DISPLAY_ITEMS(i, expected, actual)
 #endif
 
 #define EXPECT_DISPLAY_LIST(actual, expectedSize, ...) { \
     EXPECT_EQ((size_t)expectedSize, actual.size()); \
     const TestDisplayItem expected[] = { __VA_ARGS__ }; \
     for (size_t index = 0; index < std::min<size_t>(actual.size(), expectedSize); index++) { \
-        TRACE_DISPLAY_ITEMS(expected[index], *actual[index]); \
+        TRACE_DISPLAY_ITEMS(index, expected[index], *actual[index]); \
         EXPECT_EQ(expected[index].client(), actual[index]->client()); \
         EXPECT_EQ(expected[index].type(), actual[index]->type()); \
     } \
 }
 
 void drawRect(GraphicsContext* context, RenderObject* renderer, PaintPhase phase, const FloatRect& bound)
 {
     RenderDrawingRecorder drawingRecorder(context, *renderer, phase, bound);
     if (drawingRecorder.canUseCachedDrawing())
         return;
     IntRect rect(0, 0, 10, 10);
     context->drawRect(rect);
 }
 
 void drawClippedRect(GraphicsContext* context, RenderLayerModelObject* renderer, PaintPhase phase, const FloatRect& bound)
 {
     IntRect rect(1, 1, 9, 9);
     ClipRect clipRect(rect);
     LayerClipRecorder layerClipRecorder(renderer, context, DisplayItem::ClipLayerForeground, clipRect, 0, LayoutPoint(), PaintLayerFlags());
     drawRect(context, renderer, phase, bound);
 }
 
-TEST_F(ViewDisplayListTest, ViewDisplayListTest_NestedRecorders)
+TEST_F(ViewDisplayListTest, NestedRecorders)
 {
     GraphicsContext context(nullptr, &rootDisplayItemList());
     FloatRect bound = renderView()->viewRect();
 
     drawClippedRect(&context, renderView(), PaintPhaseForeground, bound);
     rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 3,
         TestDisplayItem(renderView(), DisplayItem::ClipLayerForeground),
         TestDisplayItem(renderView(), DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
         TestDisplayItem(renderView(), DisplayItem::clipTypeToEndClipType(DisplayItem::ClipLayerForeground)));
 }
 
-TEST_F(ViewDisplayListTest, ViewDisplayListTest_UpdateBasic)
+TEST_F(ViewDisplayListTest, UpdateBasic)
 {
     setBodyInnerHTML("<div id='first'><div id='second'></div></div>");
     RenderObject* first = document().body()->firstChild()->renderer();
     RenderObject* second = document().body()->firstChild()->firstChild()->renderer();
     GraphicsContext context(nullptr, &rootDisplayItemList());
 
     drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 300, 300));
     drawRect(&context, second, PaintPhaseChildBlockBackground, FloatRect(100, 100, 200, 200));
     drawRect(&context, first, PaintPhaseOutline, FloatRect(100, 100, 300, 300));
     rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 3,
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseChildBlockBackground)),
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
 
     rootDisplayItemList().invalidate(second->displayItemClient());
     drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 300, 300));
     drawRect(&context, first, PaintPhaseOutline, FloatRect(100, 100, 300, 300));
     rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 2,
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
 }
 
-TEST_F(ViewDisplayListTest, ViewDisplayListTest_UpdateSwapOrder)
+TEST_F(ViewDisplayListTest, UpdateSwapOrder)
 {
     setBodyInnerHTML("<div id='first'><div id='second'></div></div><div id='unaffected'></div>");
     RenderObject* first = document().body()->firstChild()->renderer();
     RenderObject* second = document().body()->firstChild()->firstChild()->renderer();
     RenderObject* unaffected = document().body()->firstChild()->nextSibling()->renderer();
     GraphicsContext context(nullptr, &rootDisplayItemList());
 
     drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 100, 100));
     drawRect(&context, second, PaintPhaseBlockBackground, FloatRect(100, 100, 50, 200));
     drawRect(&context, unaffected, PaintPhaseBlockBackground, FloatRect(300, 300, 10, 10));
     rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 3,
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(unaffected, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)));
 
     rootDisplayItemList().invalidate(second->displayItemClient());
     drawRect(&context, second, PaintPhaseBlockBackground, FloatRect(100, 100, 50, 200));
     drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 100, 100));
     drawRect(&context, unaffected, PaintPhaseBlockBackground, FloatRect(300, 300, 10, 10));
     rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 3,
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(unaffected, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)));
 }
 
-TEST_F(ViewDisplayListTest, ViewDisplayListTest_UpdateNewItemInMiddle)
+TEST_F(ViewDisplayListTest, UpdateNewItemInMiddle)
 {
     setBodyInnerHTML("<div id='first'><div id='second'><div id='third'></div></div></div>");
     RenderObject* first = document().body()->firstChild()->renderer();
     RenderObject* second = document().body()->firstChild()->firstChild()->renderer();
     RenderObject* third = document().body()->firstChild()->firstChild()->firstChild()->renderer();
     GraphicsContext context(nullptr, &rootDisplayItemList());
 
     drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 100, 100));
     drawRect(&context, second, PaintPhaseBlockBackground, FloatRect(100, 100, 50, 200));
     rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 2,
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)));
 
     rootDisplayItemList().invalidate(third->displayItemClient());
     drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 100, 100));
     drawRect(&context, third, PaintPhaseBlockBackground, FloatRect(125, 100, 200, 50));
     drawRect(&context, second, PaintPhaseBlockBackground, FloatRect(100, 100, 50, 200));
     rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 3,
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(third, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)));
 }
 
-TEST_F(ViewDisplayListTest, ViewDisplayListTest_UpdateInvalidationWithPhases)
+TEST_F(ViewDisplayListTest, UpdateInvalidationWithPhases)
 {
     setBodyInnerHTML("<div id='first'><div id='second'></div></div><div id='third'></div>");
     RenderObject* first = document().body()->firstChild()->renderer();
     RenderObject* second = document().body()->firstChild()->firstChild()->renderer();
     RenderObject* third = document().body()->firstChild()->nextSibling()->renderer();
     GraphicsContext context(nullptr, &rootDisplayItemList());
 
     drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 100, 100));
     drawRect(&context, second, PaintPhaseBlockBackground, FloatRect(100, 100, 50, 200));
     drawRect(&context, third, PaintPhaseBlockBackground, FloatRect(300, 100, 50, 50));
@@ skipping 31 matching lines @@
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 9,
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(third, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
         TestDisplayItem(third, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)),
         TestDisplayItem(third, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
-
-    // The following is only applicable when we support incremental paint.
-#if 0
-    rootDisplayItemList().invalidate(second->displayItemClient());
-
-    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 6,
-        TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
-        TestDisplayItem(third, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
-        TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
-        TestDisplayItem(third, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
-        TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)),
-        TestDisplayItem(third, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
-#endif
 }
 
-// This test is only applicable when we support incremental paint.
-TEST_F(ViewDisplayListTest, DISABLED_ViewDisplayListTest_UpdateAddFirstNoOverlap)
+TEST_F(ViewDisplayListTest, UpdateAddFirstOverlap)
 {
     setBodyInnerHTML("<div id='first'></div><div id='second'></div>");
     RenderObject* first = document().body()->firstChild()->renderer();
-    RenderObject* second = document().body()->firstChild()->nextSibling()->renderer();
-    GraphicsContext context(nullptr, &rootDisplayItemList());
-
-    drawRect(&context, second, PaintPhaseBlockBackground, FloatRect(200, 200, 50, 50));
-    drawRect(&context, second, PaintPhaseOutline, FloatRect(200, 200, 50, 50));
-
-    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 2,
-        TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
-        TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
-
-    rootDisplayItemList().invalidate(first->displayItemClient());
-    drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 50, 50));
-    drawRect(&context, first, PaintPhaseOutline, FloatRect(100, 100, 50, 50));
-
-    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 4,
-        TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
-        TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)),
-        TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
-        TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
-
-    rootDisplayItemList().invalidate(first->displayItemClient());
-
-    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 2,
-        TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
-        TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
-}
-
-// This test is only applicable when we support incremental paint.
-TEST_F(ViewDisplayListTest, DISABLED_ViewDisplayListTest_UpdateAddFirstOverlap)
-{
-    setBodyInnerHTML("<div id='first'></div><div id='second'></div>");
-    RenderObject* first = document().body()->firstChild()->renderer();
     RenderObject* second = document().body()->firstChild()->nextSibling()->renderer();
     GraphicsContext context(nullptr, &rootDisplayItemList());
 
     drawRect(&context, second, PaintPhaseBlockBackground, FloatRect(200, 200, 50, 50));
     drawRect(&context, second, PaintPhaseOutline, FloatRect(200, 200, 50, 50));
+    rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 2,
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
 
     rootDisplayItemList().invalidate(first->displayItemClient());
     rootDisplayItemList().invalidate(second->displayItemClient());
     drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 150, 150));
     drawRect(&context, first, PaintPhaseOutline, FloatRect(100, 100, 150, 150));
     drawRect(&context, second, PaintPhaseBlockBackground, FloatRect(200, 200, 50, 50));
     drawRect(&context, second, PaintPhaseOutline, FloatRect(200, 200, 50, 50));
+    rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 4,
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
 
     rootDisplayItemList().invalidate(first->displayItemClient());
     drawRect(&context, second, PaintPhaseBlockBackground, FloatRect(200, 200, 50, 50));
     drawRect(&context, second, PaintPhaseOutline, FloatRect(200, 200, 50, 50));
+    rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 2,
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
 }
 
-// This test is only applicable when we support incremental paint.
-TEST_F(ViewDisplayListTest, DISABLED_ViewDisplayListTest_UpdateAddLastNoOverlap)
+TEST_F(ViewDisplayListTest, UpdateAddLastOverlap)
 {
     setBodyInnerHTML("<div id='first'></div><div id='second'></div>");
     RenderObject* first = document().body()->firstChild()->renderer();
-    RenderObject* second = document().body()->firstChild()->nextSibling()->renderer();
-    GraphicsContext context(nullptr, &rootDisplayItemList());
-
-    drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 50, 50));
-    drawRect(&context, first, PaintPhaseOutline, FloatRect(100, 100, 50, 50));
-
-    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 2,
-        TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
-        TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
-
-    rootDisplayItemList().invalidate(second->displayItemClient());
-    drawRect(&context, second, PaintPhaseBlockBackground, FloatRect(200, 200, 50, 50));
-    drawRect(&context, second, PaintPhaseOutline, FloatRect(200, 200, 50, 50));
-
-    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 4,
-        TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
-        TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)),
-        TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
-        TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
-
-    rootDisplayItemList().invalidate(second->displayItemClient());
-
-    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 2,
-        TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
-        TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
-}
-
-// This test is only applicable when we support incremental paint.
-TEST_F(ViewDisplayListTest, DISABLED_ViewDisplayListTest_UpdateAddLastOverlap)
-{
-    setBodyInnerHTML("<div id='first'></div><div id='second'></div>");
-    RenderObject* first = document().body()->firstChild()->renderer();
     RenderObject* second = document().body()->firstChild()->nextSibling()->renderer();
     GraphicsContext context(nullptr, &rootDisplayItemList());
 
     drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 150, 150));
     drawRect(&context, first, PaintPhaseOutline, FloatRect(100, 100, 150, 150));
+    rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 2,
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
 
     rootDisplayItemList().invalidate(first->displayItemClient());
     rootDisplayItemList().invalidate(second->displayItemClient());
     drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 150, 150));
     drawRect(&context, first, PaintPhaseOutline, FloatRect(100, 100, 150, 150));
     drawRect(&context, second, PaintPhaseBlockBackground, FloatRect(200, 200, 50, 50));
     drawRect(&context, second, PaintPhaseOutline, FloatRect(200, 200, 50, 50));
+    rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 4,
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(second, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
 
     rootDisplayItemList().invalidate(first->displayItemClient());
     rootDisplayItemList().invalidate(second->displayItemClient());
     drawRect(&context, first, PaintPhaseBlockBackground, FloatRect(100, 100, 150, 150));
     drawRect(&context, first, PaintPhaseOutline, FloatRect(100, 100, 150, 150));
+    rootDisplayItemList().endNewPaints();
 
     EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 2,
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
         TestDisplayItem(first, DisplayItem::paintPhaseToDrawingType(PaintPhaseOutline)));
 }
 
-TEST_F(ViewDisplayListTest, ViewDisplayListTest_UpdateClip)
+TEST_F(ViewDisplayListTest, UpdateClip)
 {
     setBodyInnerHTML("<div id='first'><div id='second'></div></div>");
     RenderLayerModelObject* firstRenderer = toRenderLayerModelObject(document().body()->firstChild()->renderer());
     RenderLayerModelObject* secondRenderer = toRenderLayerModelObject(document().body()->firstChild()->firstChild()->renderer());
     GraphicsContext context(nullptr, &rootDisplayItemList());
 
     ClipRect firstClipRect(IntRect(1, 1, 2, 2));
     {
         LayerClipRecorder layerClipRecorder(firstRenderer, &context, DisplayItem::ClipLayerForeground, firstClipRect, 0, LayoutPoint(), PaintLayerFlags());
         drawRect(&context, firstRenderer, PaintPhaseBlockBackground, FloatRect(100, 100, 150, 150));
@@ skipping 71 matching lines @@
     EXPECT_TRUE(rootDisplayItemList().clientCacheIsValid(firstRenderer->displayItemClient()));
     EXPECT_TRUE(rootDisplayItemList().clientCacheIsValid(secondRenderer->displayItemClient()));
 
     rootDisplayItemList().invalidateAll();
     EXPECT_FALSE(rootDisplayItemList().clientCacheIsValid(firstRenderer->displayItemClient()));
     EXPECT_FALSE(rootDisplayItemList().clientCacheIsValid(secondRenderer->displayItemClient()));
 }
 
 TEST_F(ViewDisplayListTest, FullDocumentPaintingWithCaret)
 {
-    setBodyInnerHTML("<div id='div' contentEditable='true'>XYZ</div>");
+    setBodyInnerHTML("<div id='div' contentEditable='true' style='outline:none'>XYZ</div>");
+    document().page()->focusController().setActive(true);
+    document().page()->focusController().setFocused(true);
     RenderView* renderView = document().renderView();
     RenderLayer* rootLayer = renderView->layer();
     RenderObject* htmlRenderer = document().documentElement()->renderer();
+    RenderObject* bodyRenderer = document().body()->renderer();
     Element* div = toElement(document().body()->firstChild());
     RenderObject* divRenderer = document().body()->firstChild()->renderer();
     InlineTextBox* textInlineBox = toRenderText(div->firstChild()->renderer())->firstTextBox();
 
     SkCanvas canvas(800, 600);
     GraphicsContext context(&canvas, &rootDisplayItemList());
     LayerPaintingInfo paintingInfo(rootLayer, LayoutRect(0, 0, 800, 600), PaintBehaviorNormal, LayoutSize());
     LayerPainter(*rootLayer).paintLayerContents(&context, paintingInfo, PaintLayerPaintingCompositingAllPhases);
     rootDisplayItemList().endNewPaints();
 
-    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 2,
-        TestDisplayItem(htmlRenderer, DisplayItem::BoxDecorationBackground),
-        TestDisplayItem(textInlineBox->displayItemClient(), DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)));
+    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 10,

[chrishtr, 2015/02/04 07:08:14]

Why are there so many changes in this test?

[Xianzhu, 2015/02/04 20:46:32]

- Some test cases containing incremental painting behavior were disabled when we
disable display item caching. In this patch some of them are re-enabled. As
caching feature is tested with new test cases, the original cases are either
re-enabled with incremental painting behavior removed, or removed if test case
is no longer applicable and replaced by new tests.

- To test the caching behavior before updatePaintList(), removed the anonymous
namespace to allow the test class to be friend of DisplayItemList.

- BTW, removed redundant ViewDisplayListTest_ prefix of test case names.

+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::BoxDecorationBackground),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(bodyRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(divRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(textInlineBox->displayItemClient(), DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(divRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(bodyRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)));
 
     div->focus();
     document().view()->updateLayoutAndStyleForPainting();
     LayerPainter(*rootLayer).paintLayerContents(&context, paintingInfo, PaintLayerPaintingCompositingAllPhases);
     rootDisplayItemList().endNewPaints();
 
-    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 3,
-        TestDisplayItem(htmlRenderer, DisplayItem::BoxDecorationBackground),
-        TestDisplayItem(textInlineBox->displayItemClient(), DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
-        TestDisplayItem(divRenderer, DisplayItem::paintPhaseToDrawingType(PaintPhaseCaret)));
-}
-
-} // anonymous namespace
+    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 11,
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::BoxDecorationBackground),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(bodyRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(divRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(textInlineBox->displayItemClient(), DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(divRenderer, DisplayItem::paintPhaseToDrawingType(PaintPhaseCaret)),
+        TestDisplayItem(divRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(bodyRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)));
+}
+
+TEST_F(ViewDisplayListTest, FullDocumentPaintingWithCaret_CacheEnabled)
+{
+    RuntimeEnabledFeatures::setSlimmingPaintDisplayItemCacheEnabled(true);
+
+    setBodyInnerHTML("<div id='div' contentEditable='true' style='outline:none'>XYZ</div>");
+    document().page()->focusController().setActive(true);
+    document().page()->focusController().setFocused(true);
+    RenderView* renderView = document().renderView();
+    RenderLayer* rootLayer = renderView->layer();
+    RenderObject* htmlRenderer = document().documentElement()->renderer();
+    RenderObject* bodyRenderer = document().body()->renderer();
+    Element* div = toElement(document().body()->firstChild());
+    RenderObject* divRenderer = document().body()->firstChild()->renderer();
+    InlineTextBox* textInlineBox = toRenderText(div->firstChild()->renderer())->firstTextBox();
+
+    SkCanvas canvas(800, 600);
+    GraphicsContext context(&canvas, &rootDisplayItemList());
+    LayerPaintingInfo paintingInfo(rootLayer, LayoutRect(0, 0, 800, 600), PaintBehaviorNormal, LayoutSize());
+    LayerPainter(*rootLayer).paintLayerContents(&context, paintingInfo, PaintLayerPaintingCompositingAllPhases);
+    rootDisplayItemList().endNewPaints();
+
+    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 10,
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::BoxDecorationBackground),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(bodyRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(divRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(textInlineBox->displayItemClient(), DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(divRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(bodyRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)));
+
+    div->focus();
+    document().view()->updateLayoutAndStyleForPainting();
+    EXPECT_TRUE(rootDisplayItemList().clientCacheIsValid(htmlRenderer->displayItemClient()));
+    EXPECT_TRUE(rootDisplayItemList().clientCacheIsValid(bodyRenderer->displayItemClient()));
+    EXPECT_FALSE(rootDisplayItemList().clientCacheIsValid(divRenderer->displayItemClient()));
+    EXPECT_TRUE(rootDisplayItemList().clientCacheIsValid(textInlineBox->displayItemClient()));
+    LayerPainter(*rootLayer).paintLayerContents(&context, paintingInfo, PaintLayerPaintingCompositingAllPhases);
+    rootDisplayItemList().endNewPaints();
+
+    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 11,
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::BoxDecorationBackground),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(bodyRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(divRenderer, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(textInlineBox->displayItemClient(), DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(divRenderer, DisplayItem::paintPhaseToDrawingType(PaintPhaseCaret)),
+        TestDisplayItem(divRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(bodyRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(htmlRenderer, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)));
+}
+
+TEST_F(ViewDisplayListTest, ComplexUpdateSwapOrder)
+{
+    setBodyInnerHTML("<div id='container1'><div id='content1'></div></div>"
+        "<div id='container2'><div id='content2'></div></div>");
+    RenderObject* container1 = document().body()->firstChild()->renderer();
+    RenderObject* content1 = document().body()->firstChild()->firstChild()->renderer();
+    RenderObject* container2 = document().body()->firstChild()->nextSibling()->renderer();
+    RenderObject* content2 = document().body()->firstChild()->nextSibling()->firstChild()->renderer();
+    GraphicsContext context(nullptr, &rootDisplayItemList());
+
+    drawRect(&context, container1, PaintPhaseBlockBackground, FloatRect(100, 100, 100, 100));
+    drawRect(&context, content1, PaintPhaseBlockBackground, FloatRect(100, 100, 50, 200));
+    drawRect(&context, content1, PaintPhaseForeground, FloatRect(100, 100, 50, 200));
+    drawRect(&context, container1, PaintPhaseForeground, FloatRect(100, 100, 100, 100));
+    drawRect(&context, container2, PaintPhaseBlockBackground, FloatRect(100, 200, 100, 100));
+    drawRect(&context, content2, PaintPhaseBlockBackground, FloatRect(100, 200, 50, 200));
+    drawRect(&context, content2, PaintPhaseForeground, FloatRect(100, 200, 50, 200));
+    drawRect(&context, container2, PaintPhaseForeground, FloatRect(100, 200, 100, 100));
+    rootDisplayItemList().endNewPaints();
+
+    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 8,
+        TestDisplayItem(container1, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(content1, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(content1, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container1, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container2, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(content2, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(content2, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container2, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)));
+
+    // Simulate the situation when container1 e.g. gets a z-index that is now greater than container2.
+    rootDisplayItemList().invalidate(container1->displayItemClient());
+    drawRect(&context, container2, PaintPhaseBlockBackground, FloatRect(100, 200, 100, 100));
+    drawRect(&context, content2, PaintPhaseBlockBackground, FloatRect(100, 200, 50, 200));
+    drawRect(&context, content2, PaintPhaseForeground, FloatRect(100, 200, 50, 200));
+    drawRect(&context, container2, PaintPhaseForeground, FloatRect(100, 200, 100, 100));
+    drawRect(&context, container1, PaintPhaseBlockBackground, FloatRect(100, 100, 100, 100));
+    drawRect(&context, content1, PaintPhaseBlockBackground, FloatRect(100, 100, 50, 200));
+    drawRect(&context, content1, PaintPhaseForeground, FloatRect(100, 100, 50, 200));
+    drawRect(&context, container1, PaintPhaseForeground, FloatRect(100, 100, 100, 100));
+    rootDisplayItemList().endNewPaints();
+
+    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 8,
+        TestDisplayItem(container2, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(content2, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(content2, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container2, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container1, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(content1, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(content1, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container1, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)));
+}
+
+TEST_F(ViewDisplayListTest, CachedSubtreeSwapOrder)
+{
+    RuntimeEnabledFeatures::setSlimmingPaintDisplayItemCacheEnabled(true);
+
+    setBodyInnerHTML("<div id='container1'><div id='content1'></div></div>"
+        "<div id='container2'><div id='content2'></div></div>");
+    RenderObject* container1 = document().body()->firstChild()->renderer();
+    RenderObject* content1 = document().body()->firstChild()->firstChild()->renderer();
+    RenderObject* container2 = document().body()->firstChild()->nextSibling()->renderer();
+    RenderObject* content2 = document().body()->firstChild()->nextSibling()->firstChild()->renderer();
+    GraphicsContext context(nullptr, &rootDisplayItemList());
+
+    {
+        SubtreeInfoRecorder r(&context, *container1, PaintPhaseBlockBackground);
+        r.begin();
+        drawRect(&context, container1, PaintPhaseBlockBackground, FloatRect(100, 100, 100, 100));
+        drawRect(&context, content1, PaintPhaseBlockBackground, FloatRect(100, 100, 50, 200));
+    }
+    {
+        SubtreeInfoRecorder r(&context, *container1, PaintPhaseForeground);
+        r.begin();
+        drawRect(&context, content1, PaintPhaseForeground, FloatRect(100, 100, 50, 200));
+        drawRect(&context, container1, PaintPhaseForeground, FloatRect(100, 100, 100, 100));
+    }
+    {
+        SubtreeInfoRecorder r(&context, *container2, PaintPhaseBlockBackground);
+        r.begin();
+        drawRect(&context, container2, PaintPhaseBlockBackground, FloatRect(100, 200, 100, 100));
+        drawRect(&context, content2, PaintPhaseBlockBackground, FloatRect(100, 200, 50, 200));
+    }
+    {
+        SubtreeInfoRecorder r(&context, *container2, PaintPhaseForeground);
+        r.begin();
+        drawRect(&context, content2, PaintPhaseForeground, FloatRect(100, 200, 50, 200));
+        drawRect(&context, container2, PaintPhaseForeground, FloatRect(100, 200, 100, 100));
+    }
+    rootDisplayItemList().endNewPaints();
+
+    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 16,
+        TestDisplayItem(container1, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(container1, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(content1, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(container1, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseBlockBackground)),
+
+        TestDisplayItem(container1, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(content1, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container1, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container1, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)),
+
+        TestDisplayItem(container2, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(container2, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(content2, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(container2, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseBlockBackground)),
+
+        TestDisplayItem(container2, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(content2, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container2, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container2, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)));
+
+    // Simulate the situation when container1 e.g. gets a z-index that is now greater than container2,
+    // and at the same time container2 is scrolled out of viewport and content2 is invalidated.
+    rootDisplayItemList().invalidate(content2->displayItemClient());
+    {
+        SubtreeInfoRecorder r(&context, *container2, PaintPhaseBlockBackground);
+    }
+    EXPECT_EQ((size_t)1, newPaintListBeforeUpdate().size());
+    EXPECT_TRUE(newPaintListBeforeUpdate().last()->isSubtreeCached());
+    {
+        SubtreeInfoRecorder r(&context, *container2, PaintPhaseForeground);
+    }
+    EXPECT_EQ((size_t)2, newPaintListBeforeUpdate().size());
+    EXPECT_TRUE(newPaintListBeforeUpdate().last()->isSubtreeCached());
+    {
+        SubtreeInfoRecorder r(&context, *container1, PaintPhaseBlockBackground);
+        r.begin();
+        drawRect(&context, container1, PaintPhaseBlockBackground, FloatRect(100, 100, 100, 100));
+        drawRect(&context, content1, PaintPhaseBlockBackground, FloatRect(100, 100, 50, 200));
+    }
+    {
+        SubtreeInfoRecorder r(&context, *container1, PaintPhaseForeground);
+        r.begin();
+        drawRect(&context, content1, PaintPhaseForeground, FloatRect(100, 100, 50, 200));
+        drawRect(&context, container1, PaintPhaseForeground, FloatRect(100, 100, 100, 100));
+    }
+    rootDisplayItemList().endNewPaints();
+
+    EXPECT_DISPLAY_LIST(rootDisplayItemList().paintList(), 14,
+        TestDisplayItem(container2, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(container2, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(container2, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseBlockBackground)),
+
+        TestDisplayItem(container2, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(container2, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container2, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)),
+
+        TestDisplayItem(container1, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseBlockBackground)),
+        TestDisplayItem(container1, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(content1, DisplayItem::paintPhaseToDrawingType(PaintPhaseBlockBackground)),
+        TestDisplayItem(container1, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseBlockBackground)),
+
+        TestDisplayItem(container1, DisplayItem::paintPhaseToBeginSubtreeType(PaintPhaseForeground)),
+        TestDisplayItem(content1, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container1, DisplayItem::paintPhaseToDrawingType(PaintPhaseForeground)),
+        TestDisplayItem(container1, DisplayItem::paintPhaseToEndSubtreeType(PaintPhaseForeground)));
+}
+
 } // namespace blink