cc: Remove ScopedPtrVector and cc::remove_if.

cc/base/list_container_helper.cc

 // 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 "cc/base/list_container_helper.h"
 
 #include <algorithm>
 #include <vector>
 
-#include "cc/base/scoped_ptr_vector.h"
-
 namespace {
 const size_t kDefaultNumElementTypesToReserve = 32;
 }  // namespace
 
 namespace cc {
 
 // CharAllocator
 ////////////////////////////////////////////////////
 // This class deals only with char* and void*. It does allocation and passing
 // out raw pointers, as well as memory deallocation when being destroyed.
@@ skipping 74 matching lines @@
     char* ElementAt(size_t index) const { return data.get() + index * step; }
 
    private:
     DISALLOW_COPY_AND_ASSIGN(InnerList);
   };
 
   explicit CharAllocator(size_t element_size)
       : element_size_(element_size),
         size_(0),
         last_list_index_(0),
-        last_list_(NULL) {
+        last_list_(nullptr) {
     AllocateNewList(kDefaultNumElementTypesToReserve);
-    last_list_ = storage_[last_list_index_];
+    last_list_ = storage_[last_list_index_].get();
   }
 
   CharAllocator(size_t element_size, size_t element_count)
       : element_size_(element_size),
         size_(0),
         last_list_index_(0),
-        last_list_(NULL) {
+        last_list_(nullptr) {
     AllocateNewList(element_count > 0 ? element_count
                                       : kDefaultNumElementTypesToReserve);
-    last_list_ = storage_[last_list_index_];
+    last_list_ = storage_[last_list_index_].get();
   }
 
   ~CharAllocator() {}
 
   void* Allocate() {
     if (last_list_->IsFull()) {
       // Only allocate a new list if there isn't a spare one still there from
       // previous usage.
       if (last_list_index_ + 1 >= storage_.size())
         AllocateNewList(last_list_->capacity * 2);
 
       ++last_list_index_;
-      last_list_ = storage_[last_list_index_];
+      last_list_ = storage_[last_list_index_].get();
     }
 
     ++size_;
     return last_list_->AddElement();
   }
 
   size_t element_size() const { return element_size_; }
   size_t list_count() const { return storage_.size(); }
   size_t size() const { return size_; }
   bool IsEmpty() const { return size() == 0; }
 
   size_t Capacity() const {
     size_t capacity_sum = 0;
     for (const auto& inner_list : storage_)
       capacity_sum += inner_list->capacity;
     return capacity_sum;
   }
 
   void Clear() {
     // Remove all except for the first InnerList.
     DCHECK(!storage_.empty());
     storage_.erase(storage_.begin() + 1, storage_.end());
     last_list_index_ = 0;
-    last_list_ = storage_[0];
+    last_list_ = storage_[0].get();
     last_list_->size = 0;
     size_ = 0;
   }
 
   void RemoveLast() {
     DCHECK(!IsEmpty());
     last_list_->RemoveLast();
     if (last_list_->IsEmpty() && last_list_index_ > 0) {
       --last_list_index_;
-      last_list_ = storage_[last_list_index_];
+      last_list_ = storage_[last_list_index_].get();
 
       // If there are now two empty inner lists, free one of them.
       if (last_list_index_ + 2 < storage_.size())
         storage_.pop_back();
     }
     --size_;
   }
 
   void Erase(PositionInCharAllocator* position) {
     DCHECK_EQ(this, position->ptr_to_container);
 
     // Update |position| to point to the element after the erased element.
-    InnerList* list = storage_[position->vector_index];
+    InnerList* list = storage_[position->vector_index].get();
     char* item_iterator = position->item_iterator;
     if (item_iterator == list->LastElement())
       position->Increment();
 
     list->Erase(item_iterator);
     // TODO(weiliangc): Free the InnerList if it is empty.
     --size_;
   }
 
   void InsertBefore(ListContainerHelper::Iterator* position, size_t count) {
@@ skipping 12 matching lines @@
         Allocate();
     } else {
       storage_[position->vector_index]->InsertBefore(&position->item_iterator,
                                                      count);
       size_ += count;
     }
   }
 
   InnerList* InnerListById(size_t id) const {
     DCHECK_LT(id, storage_.size());
-    return storage_[id];
+    return storage_[id].get();
   }
 
   size_t FirstInnerListId() const {
     // |size_| > 0 means that at least one vector in |storage_| will be
     // non-empty.
     DCHECK_GT(size_, 0u);
     size_t id = 0;
     while (storage_[id]->size == 0)
       ++id;
     return id;
@@ skipping 16 matching lines @@
  private:
   void AllocateNewList(size_t list_size) {
     scoped_ptr<InnerList> new_list(new InnerList);
     new_list->capacity = list_size;
     new_list->size = 0;
     new_list->step = element_size_;
     new_list->data.reset(new char[list_size * element_size_]);
     storage_.push_back(new_list.Pass());
   }
 
-  ScopedPtrVector<InnerList> storage_;
+  std::vector<scoped_ptr<InnerList>> storage_;
   const size_t element_size_;
 
   // The number of elements in the list.
   size_t size_;
 
   // The index of the last list to have had elements added to it, or the only
   // list if the container has not had elements added since being cleared.
   size_t last_list_index_;
 
   // This is equivalent to |storage_[last_list_index_]|.
@@ skipping 287 matching lines @@
     : PositionInCharAllocator(container, vector_ind, item_iter),
       index_(index) {}
 
 ListContainerHelper::ConstReverseIterator::~ConstReverseIterator() {}
 
 size_t ListContainerHelper::ConstReverseIterator::index() const {
   return index_;
 }
 
 }  // namespace cc