replace OVERRIDE and FINAL with override and final in chrome/browser/[a-i]*

chrome/browser/extensions/api/networking_private/networking_private_apitest.cc

 // Copyright 2014 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 <map>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "chrome/browser/extensions/api/networking_private/networking_private_delegate.h"
@@ skipping 22 matching lines @@
 
 class TestDelegate : public KeyedService,
                      public NetworkingPrivateDelegate {
  public:
   TestDelegate() : fail_(false) {
   }
 
   // Asynchronous methods
   virtual void GetProperties(const std::string& guid,
                              const DictionaryCallback& success_callback,
-                             const FailureCallback& failure_callback) OVERRIDE {
+                             const FailureCallback& failure_callback) override {
     DictionaryResult(guid, success_callback, failure_callback);
   }
 
   virtual void GetManagedProperties(
       const std::string& guid,
       const DictionaryCallback& success_callback,
-      const FailureCallback& failure_callback) OVERRIDE {
+      const FailureCallback& failure_callback) override {
     DictionaryResult(guid, success_callback, failure_callback);
   }
 
   virtual void GetState(const std::string& guid,
                         const DictionaryCallback& success_callback,
-                        const FailureCallback& failure_callback) OVERRIDE {
+                        const FailureCallback& failure_callback) override {
     DictionaryResult(guid, success_callback, failure_callback);
   }
 
 
   virtual void SetProperties(const std::string& guid,
                              scoped_ptr<base::DictionaryValue> properties,
                              const VoidCallback& success_callback,
-                             const FailureCallback& failure_callback) OVERRIDE {
+                             const FailureCallback& failure_callback) override {
     VoidResult(success_callback, failure_callback);
   }
 
   virtual void CreateNetwork(bool shared,
                              scoped_ptr<base::DictionaryValue> properties,
                              const StringCallback& success_callback,
-                             const FailureCallback& failure_callback) OVERRIDE {
+                             const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
   virtual void GetNetworks(const std::string& network_type,
                            bool configured_only,
                            bool visible_only,
                            int limit,
                            const NetworkListCallback& success_callback,
-                           const FailureCallback& failure_callback) OVERRIDE {
+                           const FailureCallback& failure_callback) override {
     if (fail_) {
       failure_callback.Run(kFailure);
     } else {
       scoped_ptr<base::ListValue> result(new base::ListValue);
       scoped_ptr<base::DictionaryValue> network(new base::DictionaryValue);
       network->SetString(::onc::network_config::kType,
                          ::onc::network_config::kEthernet);
       network->SetString(::onc::network_config::kGUID, kGuid);
       result->Append(network.release());
       success_callback.Run(result.Pass());
     }
   }
 
   virtual void StartConnect(const std::string& guid,
                             const VoidCallback& success_callback,
-                            const FailureCallback& failure_callback) OVERRIDE {
+                            const FailureCallback& failure_callback) override {
     VoidResult(success_callback, failure_callback);
   }
 
   virtual void StartDisconnect(
       const std::string& guid,
       const VoidCallback& success_callback,
-      const FailureCallback& failure_callback) OVERRIDE {
+      const FailureCallback& failure_callback) override {
     VoidResult(success_callback, failure_callback);
   }
 
   virtual void VerifyDestination(
       const VerificationProperties& verification_properties,
       const BoolCallback& success_callback,
-      const FailureCallback& failure_callback) OVERRIDE {
+      const FailureCallback& failure_callback) override {
     BoolResult(success_callback, failure_callback);
   }
 
   virtual void VerifyAndEncryptCredentials(
       const std::string& guid,
       const VerificationProperties& verification_properties,
       const StringCallback& success_callback,
-      const FailureCallback& failure_callback) OVERRIDE {
+      const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
   virtual void VerifyAndEncryptData(
       const VerificationProperties& verification_properties,
       const std::string& data,
       const StringCallback& success_callback,
-      const FailureCallback& failure_callback) OVERRIDE {
+      const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
   virtual void SetWifiTDLSEnabledState(
       const std::string& ip_or_mac_address,
       bool enabled,
       const StringCallback& success_callback,
-      const FailureCallback& failure_callback) OVERRIDE {
+      const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
   virtual void GetWifiTDLSStatus(
       const std::string& ip_or_mac_address,
       const StringCallback& success_callback,
-      const FailureCallback& failure_callback) OVERRIDE {
+      const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
   virtual void GetCaptivePortalStatus(
       const std::string& guid,
       const StringCallback& success_callback,
-      const FailureCallback& failure_callback) OVERRIDE {
+      const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
   // Synchronous methods
-  virtual scoped_ptr<base::ListValue> GetEnabledNetworkTypes() OVERRIDE {
+  virtual scoped_ptr<base::ListValue> GetEnabledNetworkTypes() override {
     scoped_ptr<base::ListValue> result;
     if (!fail_) {
       result.reset(new base::ListValue);
       result->AppendString(::onc::network_config::kEthernet);
     }
     return result.Pass();
   }
 
-  virtual bool EnableNetworkType(const std::string& type) OVERRIDE{
+  virtual bool EnableNetworkType(const std::string& type) override{
     enabled_[type] = true;
     return !fail_;
   }
 
-  virtual bool DisableNetworkType(const std::string& type) OVERRIDE {
+  virtual bool DisableNetworkType(const std::string& type) override {
     disabled_[type] = true;
     return !fail_;
   }
 
-  virtual bool RequestScan() OVERRIDE {
+  virtual bool RequestScan() override {
     scan_requested_.push_back(true);
     return !fail_;
   }
 
   void set_fail(bool fail) { fail_ = fail; }
   bool GetEnabled(const std::string& type) { return enabled_[type]; }
   bool GetDisabled(const std::string& type) { return disabled_[type]; }
   size_t GetScanRequested() { return scan_requested_.size(); }
 
  private:
@@ skipping 50 matching lines @@
     if (!s_test_delegate_)
       s_test_delegate_ = new TestDelegate;
   }
 
   static KeyedService* GetNetworkingPrivateDelegate(
       content::BrowserContext* profile) {
     CHECK(s_test_delegate_);
     return s_test_delegate_;
   }
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     ExtensionApiTest::SetUpCommandLine(command_line);
     // Whitelist the extension ID of the test extension.
     command_line->AppendSwitchASCII(
         extensions::switches::kWhitelistedExtensionID,
         "epcifkihnkjgphfkloaaleeakhpmgdmn");
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     ExtensionApiTest::SetUpOnMainThread();
 #if defined(OS_CHROMEOS)
     NetworkingPrivateChromeOSFactory::GetInstance()->SetTestingFactory(
         profile(),
         &NetworkingPrivateApiTest::GetNetworkingPrivateDelegate);
 #else
     NetworkingPrivateServiceClientFactory::GetInstance()->SetTestingFactory(
         profile(),
         &NetworkingPrivateApiTest::GetNetworkingPrivateDelegate);
 #endif
@@ skipping 199 matching lines @@
   EXPECT_FALSE(RunNetworkingSubtest("getWifiTDLSStatus")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetCaptivePortalStatus) {
   EXPECT_FALSE(RunNetworkingSubtest("getCaptivePortalStatus")) << message_;
 }
 
 #endif // defined(OS_WIN)
 
 }  // namespace extensions