replace OVERRIDE and FINAL with override and final in net/

net/quic/quic_connection_helper.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 "net/quic/quic_connection_helper.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/task_runner.h"
@@ skipping 11 matching lines @@
   QuicChromeAlarm(const QuicClock* clock,
                   base::TaskRunner* task_runner,
                   QuicAlarm::Delegate* delegate)
       : QuicAlarm(delegate),
         clock_(clock),
         task_runner_(task_runner),
         task_deadline_(QuicTime::Zero()),
         weak_factory_(this) {}
 
  protected:
-  virtual void SetImpl() OVERRIDE {
+  virtual void SetImpl() override {
     DCHECK(deadline().IsInitialized());
     if (task_deadline_.IsInitialized()) {
       if (task_deadline_ <= deadline()) {
         // Since tasks can not be un-posted, OnAlarm will be invoked which
         // will notice that deadline has not yet been reached, and will set
         // the alarm for the new deadline.
         return;
       }
       // The scheduled task is after new deadline.  Invalidate the weak ptrs
       // so that task does not execute when we're not expecting it.
       weak_factory_.InvalidateWeakPtrs();
     }
 
     int64 delay_us = deadline().Subtract(clock_->Now()).ToMicroseconds();
     if (delay_us < 0) {
       delay_us = 0;
     }
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&QuicChromeAlarm::OnAlarm, weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMicroseconds(delay_us));
     task_deadline_ = deadline();
   }
 
-  virtual void CancelImpl() OVERRIDE {
+  virtual void CancelImpl() override {
     DCHECK(!deadline().IsInitialized());
     // Since tasks can not be un-posted, OnAlarm will be invoked which
     // will notice that deadline is not Initialized and will do nothing.
   }
 
  private:
   void OnAlarm() {
     DCHECK(task_deadline_.IsInitialized());
     task_deadline_ = QuicTime::Zero();
     // The alarm may have been cancelled.
@@ skipping 41 matching lines @@
 
 QuicRandom* QuicConnectionHelper::GetRandomGenerator() {
   return random_generator_;
 }
 
 QuicAlarm* QuicConnectionHelper::CreateAlarm(QuicAlarm::Delegate* delegate) {
   return new QuicChromeAlarm(clock_, task_runner_, delegate);
 }
 
 }  // namespace net