replace OVERRIDE and FINAL with override and final in net/

net/proxy/multi_threaded_proxy_resolver.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/proxy/multi_threaded_proxy_resolver.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_util.h"
@@ skipping 157 matching lines @@
  public:
   SetPacScriptJob(const scoped_refptr<ProxyResolverScriptData>& script_data,
                   const CompletionCallback& callback)
     : Job(!callback.is_null() ? TYPE_SET_PAC_SCRIPT :
                                 TYPE_SET_PAC_SCRIPT_INTERNAL,
           callback),
       script_data_(script_data) {
   }
 
   // Runs on the worker thread.
-  virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) OVERRIDE {
+  virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) override {
     ProxyResolver* resolver = executor()->resolver();
     int rv = resolver->SetPacScript(script_data_, CompletionCallback());
 
     DCHECK_NE(rv, ERR_IO_PENDING);
     origin_loop->PostTask(
         FROM_HERE,
         base::Bind(&SetPacScriptJob::RequestComplete, this, rv));
   }
 
  protected:
@@ skipping 26 matching lines @@
       : Job(TYPE_GET_PROXY_FOR_URL, callback),
         results_(results),
         net_log_(net_log),
         url_(url),
         was_waiting_for_thread_(false) {
     DCHECK(!callback.is_null());
   }
 
   BoundNetLog* net_log() { return &net_log_; }
 
-  virtual void WaitingForThread() OVERRIDE {
+  virtual void WaitingForThread() override {
     was_waiting_for_thread_ = true;
     net_log_.BeginEvent(NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD);
   }
 
-  virtual void FinishedWaitingForThread() OVERRIDE {
+  virtual void FinishedWaitingForThread() override {
     DCHECK(executor());
 
     if (was_waiting_for_thread_) {
       net_log_.EndEvent(NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD);
     }
 
     net_log_.AddEvent(
         NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD,
         NetLog::IntegerCallback("thread_number", executor()->thread_number()));
   }
 
   // Runs on the worker thread.
-  virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) OVERRIDE {
+  virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) override {
     ProxyResolver* resolver = executor()->resolver();
     int rv = resolver->GetProxyForURL(
         url_, &results_buf_, CompletionCallback(), NULL, net_log_);
     DCHECK_NE(rv, ERR_IO_PENDING);
 
     origin_loop->PostTask(
         FROM_HERE,
         base::Bind(&GetProxyForURLJob::QueryComplete, this, rv));
   }
 
@@ skipping 277 matching lines @@
     return;
 
   // Get the next job to process (FIFO). Transfer it from the pending queue
   // to the executor.
   scoped_refptr<Job> job = pending_jobs_.front();
   pending_jobs_.pop_front();
   executor->StartJob(job.get());
 }
 
 }  // namespace net