Standardize usage of virtual/override/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 {
+  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:
-  virtual ~SetPacScriptJob() {}
+  ~SetPacScriptJob() override {}
 
  private:
   // Runs the completion callback on the origin thread.
   void RequestComplete(int result_code) {
     // The task may have been cancelled after it was started.
     if (!was_cancelled() && has_user_callback()) {
       RunUserCallback(result_code);
     }
     OnJobCompleted();
   }
@@ skipping 15 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 {
+  void WaitingForThread() override {
     was_waiting_for_thread_ = true;
     net_log_.BeginEvent(NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD);
   }
 
-  virtual void FinishedWaitingForThread() override {
+  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 {
+  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));
   }
 
  protected:
-  virtual ~GetProxyForURLJob() {}
+  ~GetProxyForURLJob() override {}
 
  private:
   // Runs the completion callback on the origin thread.
   void QueryComplete(int result_code) {
     // The Job may have been cancelled after it was started.
     if (!was_cancelled()) {
       if (result_code >= OK) {  // Note: unit-tests use values > 0.
         results_->Use(results_buf_);
       }
       RunUserCallback(result_code);
@@ skipping 265 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