Convert //base to use std::unique_ptr

base/trace_event/trace_buffer.cc

 // 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 "base/trace_event/trace_buffer.h"
 
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/trace_event/trace_event_impl.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
 class TraceBufferRingBuffer : public TraceBuffer {
  public:
   TraceBufferRingBuffer(size_t max_chunks)
       : max_chunks_(max_chunks),
         recyclable_chunks_queue_(new size_t[queue_capacity()]),
         queue_head_(0),
         queue_tail_(max_chunks),
         current_iteration_index_(0),
         current_chunk_seq_(1) {
     chunks_.reserve(max_chunks);
     for (size_t i = 0; i < max_chunks; ++i)
       recyclable_chunks_queue_[i] = i;
   }
 
-  scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
+  std::unique_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
     // Because the number of threads is much less than the number of chunks,
     // the queue should never be empty.
     DCHECK(!QueueIsEmpty());
 
     *index = recyclable_chunks_queue_[queue_head_];
     queue_head_ = NextQueueIndex(queue_head_);
     current_iteration_index_ = queue_head_;
 
     if (*index >= chunks_.size())
       chunks_.resize(*index + 1);
 
     TraceBufferChunk* chunk = chunks_[*index].release();
     chunks_[*index] = NULL;  // Put NULL in the slot of a in-flight chunk.
     if (chunk)
       chunk->Reset(current_chunk_seq_++);
     else
       chunk = new TraceBufferChunk(current_chunk_seq_++);
 
-    return scoped_ptr<TraceBufferChunk>(chunk);
+    return std::unique_ptr<TraceBufferChunk>(chunk);
   }
 
-  void ReturnChunk(size_t index, scoped_ptr<TraceBufferChunk> chunk) override {
+  void ReturnChunk(size_t index,
+                   std::unique_ptr<TraceBufferChunk> chunk) override {
     // When this method is called, the queue should not be full because it
     // can contain all chunks including the one to be returned.
     DCHECK(!QueueIsFull());
     DCHECK(chunk);
     DCHECK_LT(index, chunks_.size());
     DCHECK(!chunks_[index]);
     chunks_[index] = std::move(chunk);
     recyclable_chunks_queue_[queue_tail_] = index;
     queue_tail_ = NextQueueIndex(queue_tail_);
   }
@@ skipping 62 matching lines @@
   }
 
   size_t NextQueueIndex(size_t index) const {
     index++;
     if (index >= queue_capacity())
       index = 0;
     return index;
   }
 
   size_t max_chunks_;
-  std::vector<scoped_ptr<TraceBufferChunk>> chunks_;
+  std::vector<std::unique_ptr<TraceBufferChunk>> chunks_;
 
-  scoped_ptr<size_t[]> recyclable_chunks_queue_;
+  std::unique_ptr<size_t[]> recyclable_chunks_queue_;
   size_t queue_head_;
   size_t queue_tail_;
 
   size_t current_iteration_index_;
   uint32_t current_chunk_seq_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceBufferRingBuffer);
 };
 
 class TraceBufferVector : public TraceBuffer {
  public:
   TraceBufferVector(size_t max_chunks)
       : in_flight_chunk_count_(0),
         current_iteration_index_(0),
         max_chunks_(max_chunks) {
     chunks_.reserve(max_chunks_);
   }
 
-  scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
+  std::unique_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
     // This function may be called when adding normal events or indirectly from
     // AddMetadataEventsWhileLocked(). We can not DECHECK(!IsFull()) because we
     // have to add the metadata events and flush thread-local buffers even if
     // the buffer is full.
     *index = chunks_.size();
     chunks_.push_back(NULL);  // Put NULL in the slot of a in-flight chunk.
     ++in_flight_chunk_count_;
     // + 1 because zero chunk_seq is not allowed.
-    return scoped_ptr<TraceBufferChunk>(
+    return std::unique_ptr<TraceBufferChunk>(
         new TraceBufferChunk(static_cast<uint32_t>(*index) + 1));
   }
 
-  void ReturnChunk(size_t index, scoped_ptr<TraceBufferChunk> chunk) override {
+  void ReturnChunk(size_t index,
+                   std::unique_ptr<TraceBufferChunk> chunk) override {
     DCHECK_GT(in_flight_chunk_count_, 0u);
     DCHECK_LT(index, chunks_.size());
     DCHECK(!chunks_[index]);
     --in_flight_chunk_count_;
     chunks_[index] = chunk.release();
   }
 
   bool IsFull() const override { return chunks_.size() >= max_chunks_; }
 
   size_t Size() const override {
@@ skipping 145 matching lines @@
 TraceBuffer* TraceBuffer::CreateTraceBufferRingBuffer(size_t max_chunks) {
   return new TraceBufferRingBuffer(max_chunks);
 }
 
 TraceBuffer* TraceBuffer::CreateTraceBufferVectorOfSize(size_t max_chunks) {
   return new TraceBufferVector(max_chunks);
 }
 
 }  // namespace trace_event
 }  // namespace base