Convert //cc from scoped_ptr to std::unique_ptr.

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 <stddef.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 11 matching lines @@
 ////////////////////////////////////////////////////
 // This class deals only with char* and void*. It does allocation and passing
 // out raw pointers, as well as memory deallocation when being destroyed.
 class ListContainerHelper::CharAllocator {
  public:
   // CharAllocator::InnerList
   /////////////////////////////////////////////
   // This class holds the raw memory chunk, as well as information about its
   // size and availability.
   struct InnerList {
-    scoped_ptr<char[]> data;
+    std::unique_ptr<char[]> data;
     // The number of elements in total the memory can hold. The difference
     // between capacity and size is the how many more elements this list can
     // hold.
     size_t capacity;
     // The number of elements have been put into this list.
     size_t size;
     // The size of each element is in bytes. This is used to move from between
     // elements' memory locations.
     size_t step;
 
@@ skipping 16 matching lines @@
     void InsertBefore(char** position, size_t count) {
       DCHECK_LE(*position, LastElement() + step);
       DCHECK_GE(*position, Begin());
 
       // Adjust the size and capacity
       size_t old_size = size;
       size += count;
       capacity = size;
 
       // Allocate the new data and update the iterator's pointer.
-      scoped_ptr<char[]> new_data(new char[size * step]);
+      std::unique_ptr<char[]> new_data(new char[size * step]);
       size_t position_offset = *position - Begin();
       *position = new_data.get() + position_offset;
 
       // Copy the data before the inserted segment
       memcpy(new_data.get(), data.get(), position_offset);
       // Copy the data after the inserted segment.
       memcpy(new_data.get() + position_offset + count * step,
              data.get() + position_offset, old_size * step - position_offset);
       new_data.swap(data);
     }
@@ skipping 153 matching lines @@
       --id;
     return id;
   }
 
   size_t NumAvailableElementsInLastList() const {
     return last_list_->NumElementsAvailable();
   }
 
  private:
   void AllocateNewList(size_t list_size) {
-    scoped_ptr<InnerList> new_list(new InnerList);
+    std::unique_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(std::move(new_list));
   }
 
-  std::vector<scoped_ptr<InnerList>> storage_;
+  std::vector<std::unique_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