Remove ScopedVector from trace_buffer

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 "base/memory/scoped_vector.h"

[Primiano Tucci (use gerrit), 2015/11/26 15:47:14]

remove this and add <vector> and scoped_ptr plz :)

 #include "base/trace_event/trace_event_impl.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
 class TraceBufferRingBuffer : public TraceBuffer {
  public:
   TraceBufferRingBuffer(size_t max_chunks)
@@ skipping 13 matching lines @@
     // 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];
+    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);
   }
 
   void ReturnChunk(size_t index, scoped_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] = chunk.release();
+    chunks_[index] = std::move(chunk);
     recyclable_chunks_queue_[queue_tail_] = index;
     queue_tail_ = NextQueueIndex(queue_tail_);
   }
 
   bool IsFull() const override { return false; }
 
   size_t Size() const override {
     // This is approximate because not all of the chunks are full.
     return chunks_.size() * TraceBufferChunk::kTraceBufferChunkSize;
   }
 
   size_t Capacity() const override {
     return max_chunks_ * TraceBufferChunk::kTraceBufferChunkSize;
   }
 
   TraceEvent* GetEventByHandle(TraceEventHandle handle) override {
     if (handle.chunk_index >= chunks_.size())
       return NULL;
-    TraceBufferChunk* chunk = chunks_[handle.chunk_index];
+    TraceBufferChunk* chunk = chunks_[handle.chunk_index].get();
     if (!chunk || chunk->seq() != handle.chunk_seq)
       return NULL;
     return chunk->GetEventAt(handle.event_index);
   }
 
   const TraceBufferChunk* NextChunk() override {
     if (chunks_.empty())
       return NULL;
 
     while (current_iteration_index_ != queue_tail_) {
       size_t chunk_index = recyclable_chunks_queue_[current_iteration_index_];
       current_iteration_index_ = NextQueueIndex(current_iteration_index_);
       if (chunk_index >= chunks_.size())  // Skip uninitialized chunks.
         continue;
       DCHECK(chunks_[chunk_index]);
-      return chunks_[chunk_index];
+      return chunks_[chunk_index].get();
     }
     return NULL;
   }
 
   scoped_ptr<TraceBuffer> CloneForIteration() const override {
     scoped_ptr<ClonedTraceBuffer> cloned_buffer(new ClonedTraceBuffer());
     for (size_t queue_index = queue_head_; queue_index != queue_tail_;
          queue_index = NextQueueIndex(queue_index)) {
       size_t chunk_index = recyclable_chunks_queue_[queue_index];
       if (chunk_index >= chunks_.size())  // Skip uninitialized chunks.
         continue;
-      TraceBufferChunk* chunk = chunks_[chunk_index];
-      cloned_buffer->chunks_.push_back(chunk ? chunk->Clone().release() : NULL);
+      TraceBufferChunk* chunk = chunks_[chunk_index].get();
+      cloned_buffer->chunks_.push_back(chunk ? chunk->Clone()

[Primiano Tucci (use gerrit), 2015/11/26 15:47:14]

doesn't this fit on one line?

+                                             : NULL);
     }
     return cloned_buffer.Pass();
   }
 
   void EstimateTraceMemoryOverhead(
       TraceEventMemoryOverhead* overhead) override {
     overhead->Add("TraceBufferRingBuffer", sizeof(*this));
     for (size_t queue_index = queue_head_; queue_index != queue_tail_;
          queue_index = NextQueueIndex(queue_index)) {
       size_t chunk_index = recyclable_chunks_queue_[queue_index];
       if (chunk_index >= chunks_.size())  // Skip uninitialized chunks.
         continue;
       chunks_[chunk_index]->EstimateTraceMemoryOverhead(overhead);
     }
   }
 
  private:
   class ClonedTraceBuffer : public TraceBuffer {
    public:
     ClonedTraceBuffer() : current_iteration_index_(0) {}
 
     // The only implemented method.
     const TraceBufferChunk* NextChunk() override {
       return current_iteration_index_ < chunks_.size()
-                 ? chunks_[current_iteration_index_++]
+                 ? chunks_[current_iteration_index_++].get()
                  : NULL;
     }
 
     scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
       NOTIMPLEMENTED();
       return scoped_ptr<TraceBufferChunk>();
     }
     void ReturnChunk(size_t index, scoped_ptr<TraceBufferChunk>) override {
       NOTIMPLEMENTED();
     }
     bool IsFull() const override { return false; }
     size_t Size() const override { return 0; }
     size_t Capacity() const override { return 0; }
     TraceEvent* GetEventByHandle(TraceEventHandle handle) override {
       return NULL;
     }
     scoped_ptr<TraceBuffer> CloneForIteration() const override {
       NOTIMPLEMENTED();
       return scoped_ptr<TraceBuffer>();
     }
     void EstimateTraceMemoryOverhead(
         TraceEventMemoryOverhead* overhead) override {
       NOTIMPLEMENTED();
     }
 
     size_t current_iteration_index_;
-    ScopedVector<TraceBufferChunk> chunks_;
+    std::vector<scoped_ptr<TraceBufferChunk>> chunks_;
   };
 
   bool QueueIsEmpty() const { return queue_head_ == queue_tail_; }
 
   size_t QueueSize() const {
     return queue_tail_ > queue_head_
                ? queue_tail_ - queue_head_
                : queue_tail_ + queue_capacity() - queue_head_;
   }
 
   bool QueueIsFull() const { return QueueSize() == queue_capacity() - 1; }
 
   size_t queue_capacity() const {
     // One extra space to help distinguish full state and empty state.
     return max_chunks_ + 1;
   }
 
   size_t NextQueueIndex(size_t index) const {
     index++;
     if (index >= queue_capacity())
       index = 0;
     return index;
   }
 
   size_t max_chunks_;
-  ScopedVector<TraceBufferChunk> chunks_;
+  std::vector<scoped_ptr<TraceBufferChunk>> chunks_;
 
   scoped_ptr<size_t[]> recyclable_chunks_queue_;
   size_t queue_head_;
   size_t queue_tail_;
 
   size_t current_iteration_index_;
   uint32 current_chunk_seq_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceBufferRingBuffer);
 };
@@ skipping 192 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