replace OVERRIDE and FINAL with override and final in net/

net/proxy/proxy_script_decider_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 <vector>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 89 matching lines @@
   explicit RuleBasedProxyScriptFetcher(const Rules* rules)
       : rules_(rules), request_context_(NULL) {}
 
   virtual void SetRequestContext(URLRequestContext* context) {
     request_context_ = context;
   }
 
   // ProxyScriptFetcher implementation.
   virtual int Fetch(const GURL& url,
                     base::string16* text,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     const Rules::Rule& rule = rules_->GetRuleByUrl(url);
     int rv = rule.fetch_error;
     EXPECT_NE(ERR_UNEXPECTED, rv);
     if (rv == OK)
       *text = rule.text();
     return rv;
   }
 
-  virtual void Cancel() OVERRIDE {}
+  virtual void Cancel() override {}
 
-  virtual URLRequestContext* GetRequestContext() const OVERRIDE {
+  virtual URLRequestContext* GetRequestContext() const override {
     return request_context_;
   }
 
  private:
   const Rules* rules_;
   URLRequestContext* request_context_;
 };
 
 // A mock retriever, returns asynchronously when CompleteRequests() is called.
 class MockDhcpProxyScriptFetcher : public DhcpProxyScriptFetcher {
  public:
   MockDhcpProxyScriptFetcher();
   virtual ~MockDhcpProxyScriptFetcher();
 
   virtual int Fetch(base::string16* utf16_text,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual void Cancel() OVERRIDE;
-  virtual const GURL& GetPacURL() const OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual void Cancel() override;
+  virtual const GURL& GetPacURL() const override;
 
   virtual void SetPacURL(const GURL& url);
 
   virtual void CompleteRequests(int result, const base::string16& script);
 
  private:
   CompletionCallback callback_;
   base::string16* utf16_text_;
   GURL gurl_;
   DISALLOW_COPY_AND_ASSIGN(MockDhcpProxyScriptFetcher);
@@ skipping 153 matching lines @@
   EXPECT_TRUE(decider.effective_config().has_pac_url());
   EXPECT_EQ(rule.url, decider.effective_config().pac_url());
 }
 
 class ProxyScriptDeciderQuickCheckTest : public ::testing::Test {
  public:
   ProxyScriptDeciderQuickCheckTest()
       : rule_(rules_.AddSuccessRule("http://wpad/wpad.dat")),
         fetcher_(&rules_) { }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     request_context_.set_host_resolver(&resolver_);
     fetcher_.SetRequestContext(&request_context_);
     config_.set_auto_detect(true);
     decider_.reset(new ProxyScriptDecider(&fetcher_, &dhcp_fetcher_, NULL));
   }
 
   int StartDecider() {
     return decider_->Start(config_, base::TimeDelta(), true,
                             callback_.callback());
   }
@@ skipping 312 matching lines @@
       entries, 3, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 }
 
 class SynchronousSuccessDhcpFetcher : public DhcpProxyScriptFetcher {
  public:
   explicit SynchronousSuccessDhcpFetcher(const base::string16& expected_text)
       : gurl_("http://dhcppac/"), expected_text_(expected_text) {
   }
 
   virtual int Fetch(base::string16* utf16_text,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     *utf16_text = expected_text_;
     return OK;
   }
 
-  virtual void Cancel() OVERRIDE {
+  virtual void Cancel() override {
   }
 
-  virtual const GURL& GetPacURL() const OVERRIDE {
+  virtual const GURL& GetPacURL() const override {
     return gurl_;
   }
 
   const base::string16& expected_text() const {
     return expected_text_;
   }
 
  private:
   GURL gurl_;
   base::string16 expected_text_;
@@ skipping 53 matching lines @@
 }
 
 class AsyncFailDhcpFetcher
     : public DhcpProxyScriptFetcher,
       public base::SupportsWeakPtr<AsyncFailDhcpFetcher> {
  public:
   AsyncFailDhcpFetcher() {}
   virtual ~AsyncFailDhcpFetcher() {}
 
   virtual int Fetch(base::string16* utf16_text,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     callback_ = callback;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&AsyncFailDhcpFetcher::CallbackWithFailure, AsWeakPtr()));
     return ERR_IO_PENDING;
   }
 
-  virtual void Cancel() OVERRIDE {
+  virtual void Cancel() override {
     callback_.Reset();
   }
 
-  virtual const GURL& GetPacURL() const OVERRIDE {
+  virtual const GURL& GetPacURL() const override {
     return dummy_gurl_;
   }
 
   void CallbackWithFailure() {
     if (!callback_.is_null())
       callback_.Run(ERR_PAC_NOT_IN_DHCP);
   }
 
  private:
   GURL dummy_gurl_;
@@ skipping 24 matching lines @@
 
   // Run the message loop to let the DHCP fetch complete and post the results
   // back. Before the fix linked to above, this would try to invoke on
   // the callback object provided by ProxyScriptDecider after it was
   // no longer valid.
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace
 }  // namespace net