replace OVERRIDE and FINAL with override and final in net/

net/proxy/dhcp_proxy_script_fetcher_win_unittest.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/dhcp_proxy_script_fetcher_win.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 151 matching lines @@
       : DhcpProxyScriptAdapterFetcher(url_request_context, task_runner) {
   }
 
   class DelayingDhcpQuery : public DhcpQuery {
    public:
     explicit DelayingDhcpQuery()
         : DhcpQuery() {
     }
 
     std::string ImplGetPacURLFromDhcp(
-        const std::string& adapter_name) OVERRIDE {
+        const std::string& adapter_name) override {
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20));
       return DhcpQuery::ImplGetPacURLFromDhcp(adapter_name);
     }
   };
 
-  DhcpQuery* ImplCreateDhcpQuery() OVERRIDE {
+  DhcpQuery* ImplCreateDhcpQuery() override {
     return new DelayingDhcpQuery();
   }
 };
 
 // For RealFetchWithDeferredCancel, below.
 class DelayingDhcpProxyScriptFetcherWin
     : public DhcpProxyScriptFetcherWin {
  public:
   explicit DelayingDhcpProxyScriptFetcherWin(
       URLRequestContext* context)
       : DhcpProxyScriptFetcherWin(context) {
   }
 
-  DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() OVERRIDE {
+  DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() override {
     return new DelayingDhcpProxyScriptAdapterFetcher(url_request_context(),
                                                      GetTaskRunner());
   }
 };
 
 TEST(DhcpProxyScriptFetcherWin, RealFetchWithDeferredCancel) {
   // Does a Fetch() with a slightly delayed cancel.  As before, just
   // exercises the code without stubbing out dependencies, but
   // introduces a guaranteed 20 ms delay on the worker threads so that
   // the cancel is called before they complete.
@@ skipping 14 matching lines @@
   DummyDhcpProxyScriptAdapterFetcher(URLRequestContext* context,
                                      scoped_refptr<base::TaskRunner> runner)
       : DhcpProxyScriptAdapterFetcher(context, runner),
         did_finish_(false),
         result_(OK),
         pac_script_(L"bingo"),
         fetch_delay_ms_(1) {
   }
 
   void Fetch(const std::string& adapter_name,
-             const CompletionCallback& callback) OVERRIDE {
+             const CompletionCallback& callback) override {
     callback_ = callback;
     timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(fetch_delay_ms_),
                  this, &DummyDhcpProxyScriptAdapterFetcher::OnTimer);
   }
 
-  void Cancel() OVERRIDE {
+  void Cancel() override {
     timer_.Stop();
   }
 
-  bool DidFinish() const OVERRIDE {
+  bool DidFinish() const override {
     return did_finish_;
   }
 
-  int GetResult() const OVERRIDE {
+  int GetResult() const override {
     return result_;
   }
 
-  base::string16 GetPacScript() const OVERRIDE {
+  base::string16 GetPacScript() const override {
     return pac_script_;
   }
 
   void OnTimer() {
     callback_.Run(result_);
   }
 
   void Configure(bool did_finish,
                  int result,
                  base::string16 pac_script,
@@ skipping 17 matching lines @@
  public:
   class MockAdapterQuery : public AdapterQuery {
    public:
     MockAdapterQuery() {
     }
 
     virtual ~MockAdapterQuery() {
     }
 
     virtual bool ImplGetCandidateAdapterNames(
-        std::set<std::string>* adapter_names) OVERRIDE {
+        std::set<std::string>* adapter_names) override {
       adapter_names->insert(
           mock_adapter_names_.begin(), mock_adapter_names_.end());
       return true;
     }
 
     std::vector<std::string> mock_adapter_names_;
   };
 
   MockDhcpProxyScriptFetcherWin(URLRequestContext* context)
       : DhcpProxyScriptFetcherWin(context),
@@ skipping 23 matching lines @@
                                    base::string16 pac_script,
                                    base::TimeDelta fetch_delay) {
     scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
         new DummyDhcpProxyScriptAdapterFetcher(url_request_context(),
                                                GetTaskRunner()));
     adapter_fetcher->Configure(
         did_finish, result, pac_script, fetch_delay.InMilliseconds());
     PushBackAdapter(adapter_name, adapter_fetcher.release());
   }
 
-  DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() OVERRIDE {
+  DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() override {
     ++num_fetchers_created_;
     return adapter_fetchers_[next_adapter_fetcher_index_++];
   }
 
-  virtual AdapterQuery* ImplCreateAdapterQuery() OVERRIDE {
+  virtual AdapterQuery* ImplCreateAdapterQuery() override {
     DCHECK(adapter_query_);
     return adapter_query_.get();
   }
 
-  base::TimeDelta ImplGetMaxWait() OVERRIDE {
+  base::TimeDelta ImplGetMaxWait() override {
     return max_wait_;
   }
 
-  void ImplOnGetCandidateAdapterNamesDone() OVERRIDE {
+  void ImplOnGetCandidateAdapterNamesDone() override {
     worker_finished_event_.Signal();
   }
 
   void ResetTestState() {
     // Delete any adapter fetcher objects we didn't hand out.
     std::vector<DhcpProxyScriptAdapterFetcher*>::const_iterator it
         = adapter_fetchers_.begin();
     for (; it != adapter_fetchers_.end(); ++it) {
       if (num_fetchers_created_-- <= 0) {
         delete (*it);
@@ skipping 295 matching lines @@
   }
 
   // Re-do the first test to make sure the last test that was run did
   // not leave things in a bad state.
   (*test_functions.begin())(&client);
 }
 
 }  // namespace
 
 }  // namespace net