cc: Remove unused AppendByMoving from ListContainer

R=enne@chromium.org

Bug: 832726
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I3e21bd4a54b82fcf7f9f07ae36cdfdb65034fe39
Reviewed-on: https://chromium-review.googlesource.com/1015820Reviewed-by: enne <enne@chromium.org>
Commit-Queue: danakj <danakj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#551739}

cc/base/list_container.h

@@ -146,22 +146,6 @@ class ListContainer {
     helper_.data_.swap(other.helper_.data_);
   }
 
-  // Appends a new item without copying. The original item will not be
-  // destructed and will be replaced with a new DerivedElementType. The
-  // DerivedElementType does not have to match the moved type as a full block
-  // of memory will be moved (up to MaxSizeForDerivedClass()). A pointer to
-  // the moved element is returned.
-  template <typename DerivedElementType>
-  DerivedElementType* AppendByMoving(DerivedElementType* item) {
-    size_t max_size_for_derived_class = helper_.MaxSizeForDerivedClass();
-    void* new_item = helper_.Allocate(alignof(DerivedElementType),
-                                      max_size_for_derived_class);
-    memcpy(new_item, static_cast<void*>(item), max_size_for_derived_class);
-    // Construct a new element in-place so it can be destructed safely.
-    new (item) DerivedElementType;
-    return static_cast<DerivedElementType*>(new_item);
-  }
-
   size_t size() const { return helper_.size(); }
   bool empty() const { return helper_.empty(); }
   size_t GetCapacityInBytes() const { return helper_.GetCapacityInBytes(); }

cc/base/list_container_unittest.cc

@@ -1025,168 +1025,6 @@ TEST(ListContainerTest, RemoveLastIteration) {
   check_equal();  // Empty.
 }
 
-TEST(ListContainerTest, AppendByMovingSameList) {
-  ListContainer<SimpleDerivedElement> list(
-      kCurrentLargestDerivedElementAlign, kCurrentLargestDerivedElementSize, 0);
-  list.AllocateAndConstruct<SimpleDerivedElementConstructMagicNumberOne>();
-
-  list.AppendByMoving(list.front());
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne,
-            list.back()->get_value());
-  EXPECT_EQ(2u, list.size());
-
-  list.front()->set_value(kMagicNumberToUseForSimpleDerivedElementTwo);
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementTwo,
-            list.front()->get_value());
-  list.AppendByMoving(list.front());
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementTwo,
-            list.back()->get_value());
-  EXPECT_EQ(3u, list.size());
-}
-
-TEST(ListContainerTest, AppendByMovingDoesNotDestruct) {
-  ListContainer<DerivedElement> list_1(kCurrentLargestDerivedElementAlign,
-                                       kCurrentLargestDerivedElementSize, 0);
-  ListContainer<DerivedElement> list_2(kCurrentLargestDerivedElementAlign,
-                                       kCurrentLargestDerivedElementSize, 0);
-  MockDerivedElement* mde_1 = list_1.AllocateAndConstruct<MockDerivedElement>();
-
-  // Make sure destructor isn't called during AppendByMoving.
-  mde_1->SetExpectedDestructorCalls(0);
-  list_2.AppendByMoving(mde_1);
-
-  // The element moved to list 2, but still expects no destructor calls. The
-  // expectation must be reset, as the element will be destroyed now.
-  mde_1 = static_cast<MockDerivedElement*>(list_2.back());
-  mde_1->SetExpectedDestructorCalls(1);
-}
-
-TEST(ListContainerTest, AppendByMovingReturnsMovedPointer) {
-  ListContainer<SimpleDerivedElement> list_1(
-      kCurrentLargestDerivedElementAlign, kCurrentLargestDerivedElementSize, 0);
-  ListContainer<SimpleDerivedElement> list_2(
-      kCurrentLargestDerivedElementAlign, kCurrentLargestDerivedElementSize, 0);
-  SimpleDerivedElement* simple_element =
-      list_1.AllocateAndConstruct<SimpleDerivedElement>();
-
-  SimpleDerivedElement* moved_1 = list_2.AppendByMoving(simple_element);
-  EXPECT_EQ(list_2.back(), moved_1);
-
-  SimpleDerivedElement* moved_2 = list_1.AppendByMoving(moved_1);
-  EXPECT_EQ(list_1.back(), moved_2);
-  EXPECT_NE(moved_1, moved_2);
-}
-
-TEST(ListContainerTest, AppendByMovingReplacesSourceWithNewDerivedElement) {
-  ListContainer<SimpleDerivedElement> list_1(
-      kCurrentLargestDerivedElementAlign, kCurrentLargestDerivedElementSize, 0);
-  ListContainer<SimpleDerivedElement> list_2(
-      kCurrentLargestDerivedElementAlign, kCurrentLargestDerivedElementSize, 0);
-
-  list_1.AllocateAndConstruct<SimpleDerivedElementConstructMagicNumberOne>();
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne,
-            list_1.back()->get_value());
-
-  list_2.AppendByMoving(list_1.front());
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne,
-            list_1.back()->get_value());
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne,
-            list_2.back()->get_value());
-
-  // Change the value of list_2.front() to ensure the value is actually moved.
-  list_2.back()->set_value(kMagicNumberToUseForSimpleDerivedElementThree);
-
-  list_1.AppendByMoving(list_2.back());
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne,
-            list_1.front()->get_value());
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementThree,
-            list_1.back()->get_value());
-
-  // Redo the check with another derived type.
-  list_1.AllocateAndConstruct<SimpleDerivedElementConstructMagicNumberTwo>();
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementTwo,
-            list_1.back()->get_value());
-  list_2.AppendByMoving(list_1.back());
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementTwo,
-            list_2.back()->get_value());
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementTwo,
-            list_1.back()->get_value());
-
-  // AppendByMoving replaces the source element with a new derived element so
-  // we do not expect sizes to shrink after AppendByMoving is called.
-  EXPECT_EQ(3u, list_1.size());  // Two direct allocations, one AppendByMoving.
-  EXPECT_EQ(2u, list_2.size());  // Two AppendByMoving.
-}
-
-const size_t kLongCountForLongSimpleDerivedElement = 5;
-
-class LongSimpleDerivedElement : public SimpleDerivedElement {
- public:
-  ~LongSimpleDerivedElement() override = default;
-  void SetAllValues(unsigned long value) {
-    for (size_t i = 0; i < kLongCountForLongSimpleDerivedElement; i++)
-      values[i] = value;
-  }
-  bool AreAllValuesEqualTo(size_t value) const {
-    for (size_t i = 1; i < kLongCountForLongSimpleDerivedElement; i++) {
-      if (values[i] != values[0])
-        return false;
-    }
-    return true;
-  }
-
- private:
-  unsigned long values[kLongCountForLongSimpleDerivedElement];
-};
-
-const unsigned long kMagicNumberToUseForLongSimpleDerivedElement = 2718ul;
-
-class LongSimpleDerivedElementConstructMagicNumber
-    : public LongSimpleDerivedElement {
- public:
-  LongSimpleDerivedElementConstructMagicNumber() {
-    SetAllValues(kMagicNumberToUseForLongSimpleDerivedElement);
-  }
-};
-
-TEST(ListContainerTest, AppendByMovingLongAndSimpleDerivedElements) {
-  static_assert(sizeof(LongSimpleDerivedElement) > sizeof(SimpleDerivedElement),
-                "LongSimpleDerivedElement should be larger than "
-                "SimpleDerivedElement's size.");
-  static_assert(sizeof(LongSimpleDerivedElement) <= kLargestDerivedElementSize,
-                "LongSimpleDerivedElement should be smaller than the maximum "
-                "DerivedElement size.");
-
-  ListContainer<SimpleDerivedElement> list(
-      kCurrentLargestDerivedElementAlign, kCurrentLargestDerivedElementSize, 0);
-  list.AllocateAndConstruct<LongSimpleDerivedElementConstructMagicNumber>();
-  list.AllocateAndConstruct<SimpleDerivedElementConstructMagicNumberOne>();
-
-  EXPECT_TRUE(
-      static_cast<LongSimpleDerivedElement*>(list.front())
-          ->AreAllValuesEqualTo(kMagicNumberToUseForLongSimpleDerivedElement));
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne,
-            list.back()->get_value());
-
-  // Test that moving a simple derived element actually moves enough data so
-  // that the LongSimpleDerivedElement at this location is entirely moved.
-  SimpleDerivedElement* simple_element = list.back();
-  list.AppendByMoving(list.front());
-  EXPECT_TRUE(
-      static_cast<LongSimpleDerivedElement*>(list.back())
-          ->AreAllValuesEqualTo(kMagicNumberToUseForLongSimpleDerivedElement));
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne,
-            simple_element->get_value());
-
-  LongSimpleDerivedElement* long_element =
-      static_cast<LongSimpleDerivedElement*>(list.back());
-  list.AppendByMoving(simple_element);
-  EXPECT_TRUE(long_element->AreAllValuesEqualTo(
-      kMagicNumberToUseForLongSimpleDerivedElement));
-  EXPECT_EQ(kMagicNumberToUseForSimpleDerivedElementOne,
-            list.back()->get_value());
-}
-
 TEST(ListContainerTest, Swap) {
   ListContainer<SimpleDerivedElement> list_1(
       kCurrentLargestDerivedElementAlign, kCurrentLargestDerivedElementSize, 0);