replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

chrome/browser/net/dns_probe_browsertest.cc

 // Copyright 2013 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 <set>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 64 matching lines @@
 // CallDelayedCallbacks.  This allows the DnsProbeBrowserTest to enforce a
 // stricter ordering of events.
 class DelayingDnsProbeService : public DnsProbeService {
  public:
   DelayingDnsProbeService() {}
 
   virtual ~DelayingDnsProbeService() {
     EXPECT_TRUE(delayed_probes_.empty());
   }
 
-  virtual void ProbeDns(const ProbeCallback& callback) OVERRIDE {
+  virtual void ProbeDns(const ProbeCallback& callback) override {
     delayed_probes_.push_back(callback);
   }
 
   void StartDelayedProbes() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     std::vector<ProbeCallback> probes;
     probes.swap(delayed_probes_);
 
     for (std::vector<ProbeCallback>::const_iterator i = probes.begin();
@@ skipping 40 matching lines @@
   DelayableURLRequestFailedJob(net::URLRequest* request,
                                net::NetworkDelegate* network_delegate,
                                int net_error,
                                bool should_delay,
                                const DestructionCallback& destruction_callback)
       : URLRequestFailedJob(request, network_delegate, net_error),
         should_delay_(should_delay),
         start_delayed_(false),
         destruction_callback_(destruction_callback) {}
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     if (should_delay_) {
       DCHECK(!start_delayed_);
       start_delayed_ = true;
       return;
     }
     URLRequestFailedJob::Start();
   }
 
-  virtual void Resume() OVERRIDE {
+  virtual void Resume() override {
     DCHECK(should_delay_);
     should_delay_ = false;
     if (start_delayed_) {
       start_delayed_ = false;
       Start();
     }
   }
 
  private:
   virtual ~DelayableURLRequestFailedJob() {
@@ skipping 18 matching lines @@
       : URLRequestMockHTTPJob(
             request,
             network_delegate,
             file_path,
             BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
                 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
         should_delay_(should_delay),
         start_delayed_(false),
         destruction_callback_(destruction_callback) {}
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     if (should_delay_) {
       DCHECK(!start_delayed_);
       start_delayed_ = true;
       return;
     }
     URLRequestMockHTTPJob::Start();
   }
 
-  virtual void Resume() OVERRIDE {
+  virtual void Resume() override {
     DCHECK(should_delay_);
     should_delay_ = false;
     if (start_delayed_) {
       start_delayed_ = false;
       Start();
     }
   }
 
  private:
   virtual ~DelayableURLRequestMockHTTPJob() {
@@ skipping 21 matching lines @@
                        base::Unretained(this))) {
   }
 
   virtual ~BreakableCorrectionInterceptor() {
     // All delayed requests should have been resumed or cancelled by this point.
     EXPECT_TRUE(delayed_requests_.empty());
   }
 
   virtual URLRequestJob* MaybeInterceptRequest(
       URLRequest* request,
-      NetworkDelegate* network_delegate) const OVERRIDE {
+      NetworkDelegate* network_delegate) const override {
     if (net_error_ != net::OK) {
       DelayableURLRequestFailedJob* job =
           new DelayableURLRequestFailedJob(
               request, network_delegate, net_error_, delay_requests_,
               on_request_destroyed_callback_);
       if (delay_requests_)
         delayed_requests_.insert(job);
       return job;
     } else {
       DelayableURLRequestMockHTTPJob* job =
@@ skipping 170 matching lines @@
   EXPECT_EQ(expected_delayed_probe_count, actual_delayed_probe_count);
 
   delaying_dns_probe_service_->StartDelayedProbes();
 }
 
 class DnsProbeBrowserTest : public InProcessBrowserTest {
  public:
   DnsProbeBrowserTest();
   virtual ~DnsProbeBrowserTest();
 
-  virtual void SetUpOnMainThread() OVERRIDE;
-  virtual void TearDownOnMainThread() OVERRIDE;
+  virtual void SetUpOnMainThread() override;
+  virtual void TearDownOnMainThread() override;
 
  protected:
   // Sets the browser object that other methods apply to, and that has the
   // DnsProbeStatus messages of its currently active tab monitored.
   void SetActiveBrowser(Browser* browser);
 
   void SetCorrectionServiceBroken(bool broken);
   void SetCorrectionServiceDelayRequests(bool delay_requests);
   void WaitForDelayedRequestDestruction();
   void SetMockDnsClientRules(MockDnsClientRule::Result system_result,
@@ skipping 543 matching lines @@
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE,
             WaitForSentStatus());
   EXPECT_EQ(0, pending_status_count());
   ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
 }
 
 }  // namespace
 
 }  // namespace chrome_browser_net