Blink-side contiguous allocation of display items.

Source/platform/graphics/ListContainerTest.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "platform/graphics/ListContainer.h"
 
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/RefPtr.h"
@@ skipping 135 matching lines @@
     SimpleDerivedElementConstructMagicNumberTwo* derivedElement2 = list.allocateAndConstruct<SimpleDerivedElementConstructMagicNumberTwo>();
 
     EXPECT_EQ(size, list.size());
     EXPECT_EQ(derivedElement1, list.front());
     EXPECT_EQ(derivedElement2, list.back());
 
     EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne, derivedElement1->getValue());
     EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementTwo, derivedElement2->getValue());
 }
 
+TEST(ListContainerTest, AllocateAndConstructWithArguments)
+{
+    // Create a new OwnPtr<SimpleDerivedElement> by passing in a new SimpleDerivedElement.
+    ListContainer<OwnPtr<SimpleDerivedElement>> list1(kCurrentLargestDerivedElementSize);
+    auto* sdeOwnPtr1 = list1.allocateAndConstruct<OwnPtr<SimpleDerivedElement>>(adoptPtr(new SimpleDerivedElementConstructMagicNumberOne()));
+    EXPECT_EQ(1u, list1.size());
+    EXPECT_EQ(sdeOwnPtr1, list1.back());
+    EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne, (*sdeOwnPtr1)->getValue());
+    (*sdeOwnPtr1)->setValue(kMagicNumberToUseForSimpleDerivedElementTwo);
+
+    // Transfer an OwnPtr<SimpleDerivedElement> to another list.
+    ListContainer<OwnPtr<SimpleDerivedElement>> list2(kCurrentLargestDerivedElementSize);
+    auto* sdeOwnPtr2 = list2.allocateAndConstruct<OwnPtr<SimpleDerivedElement>>(sdeOwnPtr1->release());
+    EXPECT_EQ(1u, list2.size());
+    EXPECT_EQ(sdeOwnPtr2, list2.back());
+    EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementTwo, (*sdeOwnPtr2)->getValue());
+
+    // Verify the first OwnPtr is null after moving.
+    EXPECT_EQ(nullptr, list1.back()->get());
+}
+
 TEST(ListContainerTest, DestructorCalled)
 {
     ListContainer<DerivedElement> list(kCurrentLargestDerivedElementSize);
 
     size_t size = 1;
     MockDerivedElement* derivedElement1 = list.allocateAndConstruct<MockDerivedElement>();
 
     EXPECT_CALL(*derivedElement1, Destruct());
     EXPECT_EQ(size, list.size());
     EXPECT_EQ(derivedElement1, list.front());
@@ skipping 680 matching lines @@
     MockDerivedElement* mde1 = list1.allocateAndConstruct<MockDerivedElement>();
 
     // Make sure destructor isn't called during AppendByMoving.
     list2.appendByMoving(mde1);
     EXPECT_CALL(*mde1, Destruct()).Times(0);
     testing::Mock::VerifyAndClearExpectations(mde1);
     mde1 = static_cast<MockDerivedElement*>(list2.back());
     EXPECT_CALL(*mde1, Destruct());
 }
 
+TEST(ListContainerTest, AppendByMovingReturnsMovedPointer)
+{
+    ListContainer<SimpleDerivedElement> list1(kCurrentLargestDerivedElementSize);
+    ListContainer<SimpleDerivedElement> list2(kCurrentLargestDerivedElementSize);
+    SimpleDerivedElement* simpleElement = list1.allocateAndConstruct<SimpleDerivedElement>();
+
+    SimpleDerivedElement* movedElement1 = list2.appendByMoving(simpleElement);
+    EXPECT_EQ(list2.back(), movedElement1);
+
+    SimpleDerivedElement* movedElement2 = list1.appendByMoving(movedElement1);
+    EXPECT_EQ(list1.back(), movedElement2);
+    EXPECT_NE(movedElement1, movedElement2);
+}
+
 TEST(ListContainerTest, AppendByMovingReplacesSourceWithNewDerivedElement)
 {
     ListContainer<SimpleDerivedElementConstructMagicNumberOne> list1(kCurrentLargestDerivedElementSize);
     ListContainer<SimpleDerivedElementConstructMagicNumberTwo> list2(kCurrentLargestDerivedElementSize);
 
     list1.allocateAndConstruct<SimpleDerivedElementConstructMagicNumberOne>();
     EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne,
     list1.front()->getValue());
 
     list2.appendByMoving(list1.front());
@@ skipping 104 matching lines @@
     EXPECT_EQ(2u, list1.size());
     EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne, list2.front()->getValue());
     EXPECT_EQ(1u, list2.size());
 
     // Ensure pointers are still valid after swapping.
     EXPECT_EQ(preSwapList1Front, list2.front());
 }
 
 } // namespace
 } // namespace blink