replace OVERRIDE and FINAL with override and final in base/

base/debug/trace_event_impl.cc

 // Copyright (c) 2012 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/debug/trace_event_impl.h"
 
 #include <algorithm>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
@@ skipping 122 matching lines @@
         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;
   }
 
-  virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) OVERRIDE {
+  virtual scoped_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];
     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);
   }
 
   virtual void ReturnChunk(size_t index,
-                           scoped_ptr<TraceBufferChunk> chunk) OVERRIDE {
+                           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();
     recyclable_chunks_queue_[queue_tail_] = index;
     queue_tail_ = NextQueueIndex(queue_tail_);
   }
 
-  virtual bool IsFull() const OVERRIDE {
+  virtual bool IsFull() const override {
     return false;
   }
 
-  virtual size_t Size() const OVERRIDE {
+  virtual size_t Size() const override {
     // This is approximate because not all of the chunks are full.
     return chunks_.size() * kTraceBufferChunkSize;
   }
 
-  virtual size_t Capacity() const OVERRIDE {
+  virtual size_t Capacity() const override {
     return max_chunks_ * kTraceBufferChunkSize;
   }
 
-  virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) OVERRIDE {
+  virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) override {
     if (handle.chunk_index >= chunks_.size())
       return NULL;
     TraceBufferChunk* chunk = chunks_[handle.chunk_index];
     if (!chunk || chunk->seq() != handle.chunk_seq)
       return NULL;
     return chunk->GetEventAt(handle.event_index);
   }
 
-  virtual const TraceBufferChunk* NextChunk() OVERRIDE {
+  virtual 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 NULL;
   }
 
-  virtual scoped_ptr<TraceBuffer> CloneForIteration() const OVERRIDE {
+  virtual 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);
     }
     return cloned_buffer.PassAs<TraceBuffer>();
   }
 
  private:
   class ClonedTraceBuffer : public TraceBuffer {
    public:
     ClonedTraceBuffer() : current_iteration_index_(0) {}
 
     // The only implemented method.
-    virtual const TraceBufferChunk* NextChunk() OVERRIDE {
+    virtual const TraceBufferChunk* NextChunk() override {
       return current_iteration_index_ < chunks_.size() ?
           chunks_[current_iteration_index_++] : NULL;
     }
 
-    virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) OVERRIDE {
+    virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
       NOTIMPLEMENTED();
       return scoped_ptr<TraceBufferChunk>();
     }
     virtual void ReturnChunk(size_t index,
-                             scoped_ptr<TraceBufferChunk>) OVERRIDE {
+                             scoped_ptr<TraceBufferChunk>) override {
       NOTIMPLEMENTED();
     }
-    virtual bool IsFull() const OVERRIDE { return false; }
-    virtual size_t Size() const OVERRIDE { return 0; }
-    virtual size_t Capacity() const OVERRIDE { return 0; }
-    virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) OVERRIDE {
+    virtual bool IsFull() const override { return false; }
+    virtual size_t Size() const override { return 0; }
+    virtual size_t Capacity() const override { return 0; }
+    virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) override {
       return NULL;
     }
-    virtual scoped_ptr<TraceBuffer> CloneForIteration() const OVERRIDE {
+    virtual scoped_ptr<TraceBuffer> CloneForIteration() const override {
       NOTIMPLEMENTED();
       return scoped_ptr<TraceBuffer>();
     }
 
     size_t current_iteration_index_;
     ScopedVector<TraceBufferChunk> chunks_;
   };
 
   bool QueueIsEmpty() const {
     return queue_head_ == queue_tail_;
@@ skipping 35 matching lines @@
 
 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_);
   }
 
-  virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) OVERRIDE {
+  virtual scoped_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>(
         new TraceBufferChunk(static_cast<uint32>(*index) + 1));
   }
 
   virtual void ReturnChunk(size_t index,
-                           scoped_ptr<TraceBufferChunk> chunk) OVERRIDE {
+                           scoped_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();
   }
 
-  virtual bool IsFull() const OVERRIDE {
+  virtual bool IsFull() const override {
     return chunks_.size() >= max_chunks_;
   }
 
-  virtual size_t Size() const OVERRIDE {
+  virtual size_t Size() const override {
     // This is approximate because not all of the chunks are full.
     return chunks_.size() * kTraceBufferChunkSize;
   }
 
-  virtual size_t Capacity() const OVERRIDE {
+  virtual size_t Capacity() const override {
     return max_chunks_ * kTraceBufferChunkSize;
   }
 
-  virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) OVERRIDE {
+  virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) override {
     if (handle.chunk_index >= chunks_.size())
       return NULL;
     TraceBufferChunk* chunk = chunks_[handle.chunk_index];
     if (!chunk || chunk->seq() != handle.chunk_seq)
       return NULL;
     return chunk->GetEventAt(handle.event_index);
   }
 
-  virtual const TraceBufferChunk* NextChunk() OVERRIDE {
+  virtual const TraceBufferChunk* NextChunk() override {
     while (current_iteration_index_ < chunks_.size()) {
       // Skip in-flight chunks.
       const TraceBufferChunk* chunk = chunks_[current_iteration_index_++];
       if (chunk)
         return chunk;
     }
     return NULL;
   }
 
-  virtual scoped_ptr<TraceBuffer> CloneForIteration() const OVERRIDE {
+  virtual scoped_ptr<TraceBuffer> CloneForIteration() const override {
     NOTIMPLEMENTED();
     return scoped_ptr<TraceBuffer>();
   }
 
  private:
   size_t in_flight_chunk_count_;
   size_t current_iteration_index_;
   size_t max_chunks_;
   ScopedVector<TraceBufferChunk> chunks_;
 
@@ skipping 488 matching lines @@
   TraceSampleCallback callback;
 };
 
 // This object must be created on the IO thread.
 class TraceSamplingThread : public PlatformThread::Delegate {
  public:
   TraceSamplingThread();
   virtual ~TraceSamplingThread();
 
   // Implementation of PlatformThread::Delegate:
-  virtual void ThreadMain() OVERRIDE;
+  virtual void ThreadMain() override;
 
   static void DefaultSamplingCallback(TraceBucketData* bucekt_data);
 
   void Stop();
   void WaitSamplingEventForTesting();
 
  private:
   friend class TraceLog;
 
   void GetSamples();
@@ skipping 176 matching lines @@
         handle.chunk_index != chunk_index_)
       return NULL;
 
     return chunk_->GetEventAt(handle.event_index);
   }
 
   int generation() const { return generation_; }
 
  private:
   // MessageLoop::DestructionObserver
-  virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
+  virtual void WillDestroyCurrentMessageLoop() override;
 
   void FlushWhileLocked();
 
   void CheckThisIsCurrentBuffer() const {
     DCHECK(trace_log_->thread_local_event_buffer_.Get() == this);
   }
 
   // Since TraceLog is a leaky singleton, trace_log_ will always be valid
   // as long as the thread exists.
   TraceLog* trace_log_;
@@ skipping 1491 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_,
                                                 name_, event_handle_);
   }
 }
 
 }  // namespace trace_event_internal