replace OVERRIDE and FINAL with override and final in net/

net/proxy/dhcp_proxy_script_adapter_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_adapter_fetcher_win.h"
 
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/timer/elapsed_timer.h"
@@ skipping 33 matching lines @@
         fetcher_delay_ms_(1),
         fetcher_result_(OK),
         pac_script_("bingo") {
   }
 
   void Cancel() {
     DhcpProxyScriptAdapterFetcher::Cancel();
     fetcher_ = NULL;
   }
 
-  virtual ProxyScriptFetcher* ImplCreateScriptFetcher() OVERRIDE {
+  virtual ProxyScriptFetcher* ImplCreateScriptFetcher() override {
     // We don't maintain ownership of the fetcher, it is transferred to
     // the caller.
     fetcher_ = new MockProxyScriptFetcher();
     if (fetcher_delay_ms_ != -1) {
       fetcher_timer_.Start(FROM_HERE,
           base::TimeDelta::FromMilliseconds(fetcher_delay_ms_),
           this, &MockDhcpProxyScriptAdapterFetcher::OnFetcherTimer);
     }
     return fetcher_;
   }
 
   class DelayingDhcpQuery : public DhcpQuery {
    public:
     explicit DelayingDhcpQuery()
         : DhcpQuery(),
           test_finished_event_(true, false) {
     }
 
     std::string ImplGetPacURLFromDhcp(
-        const std::string& adapter_name) OVERRIDE {
+        const std::string& adapter_name) override {
       base::ElapsedTimer timer;
       test_finished_event_.TimedWait(dhcp_delay_);
       return configured_url_;
     }
 
     base::WaitableEvent test_finished_event_;
     base::TimeDelta dhcp_delay_;
     std::string configured_url_;
   };
 
-  virtual DhcpQuery* ImplCreateDhcpQuery() OVERRIDE {
+  virtual DhcpQuery* ImplCreateDhcpQuery() override {
     dhcp_query_ = new DelayingDhcpQuery();
     dhcp_query_->dhcp_delay_ = dhcp_delay_;
     dhcp_query_->configured_url_ = configured_url_;
     return dhcp_query_;
   }
 
   // Use a shorter timeout so tests can finish more quickly.
-  virtual base::TimeDelta ImplGetTimeout() const OVERRIDE {
+  virtual base::TimeDelta ImplGetTimeout() const override {
     return timeout_;
   }
 
   void OnFetcherTimer() {
     // Note that there is an assumption by this mock implementation that
     // DhcpProxyScriptAdapterFetcher::Fetch will call ImplCreateScriptFetcher
     // and call Fetch on the fetcher before the message loop is re-entered.
     // This holds true today, but if you hit this DCHECK the problem can
     // possibly be resolved by having a separate subclass of
     // MockProxyScriptFetcher that adds the delay internally (instead of
@@ skipping 161 matching lines @@
     : public MockDhcpProxyScriptAdapterFetcher {
  public:
   explicit MockDhcpRealFetchProxyScriptAdapterFetcher(
       URLRequestContext* context,
       scoped_refptr<base::TaskRunner> task_runner)
       : MockDhcpProxyScriptAdapterFetcher(context, task_runner),
         url_request_context_(context) {
   }
 
   // Returns a real proxy script fetcher.
-  ProxyScriptFetcher* ImplCreateScriptFetcher() OVERRIDE {
+  ProxyScriptFetcher* ImplCreateScriptFetcher() override {
     ProxyScriptFetcher* fetcher =
         new ProxyScriptFetcherImpl(url_request_context_);
     return fetcher;
   }
 
   URLRequestContext* url_request_context_;
 };
 
 TEST(DhcpProxyScriptAdapterFetcher, MockDhcpRealFetch) {
   SpawnedTestServer test_server(
@@ skipping 43 matching lines @@
   EXPECT_EQ(BASE_URL,
             DhcpProxyScriptAdapterFetcher::SanitizeDhcpApiString(
                 BASE_URL "\0foo\0blat", kBaseUrlLen + 9));
 }
 
 #undef BASE_URL
 
 }  // namespace
 
 }  // namespace net