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

chrome/browser/extensions/api/networking_private/networking_private_service_client_apitest.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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/networking_private/networking_private_credentials_getter.h"
@@ skipping 20 matching lines @@
 // dependency.
 
 namespace {
 
 // Stub Verify* methods implementation to satisfy expectations of
 // networking_private_apitest.
 class CryptoVerifyStub
     : public extensions::NetworkingPrivateServiceClient::CryptoVerify {
   virtual void VerifyDestination(const Credentials& verification_properties,
                                  bool* verified,
-                                 std::string* error) OVERRIDE {
+                                 std::string* error) override {
     *verified = true;
   }
 
   virtual void VerifyAndEncryptCredentials(
       const std::string& network_guid,
       const Credentials& credentials,
-      const VerifyAndEncryptCredentialsCallback& callback) OVERRIDE {
+      const VerifyAndEncryptCredentialsCallback& callback) override {
     callback.Run("encrypted_credentials", "");
   }
 
   virtual void VerifyAndEncryptData(const Credentials& verification_properties,
                                     const std::string& data,
                                     std::string* base64_encoded_ciphertext,
-                                    std::string* error) OVERRIDE {
+                                    std::string* error) override {
     *base64_encoded_ciphertext = "encrypted_data";
   }
 };
 
 class NetworkingPrivateServiceClientApiTest : public ExtensionApiTest {
  public:
   NetworkingPrivateServiceClientApiTest() {}
 
   bool RunNetworkingSubtest(const std::string& subtest) {
     return RunExtensionSubtest("networking",
                                "main.html?" + subtest,
                                kFlagEnableFileAccess | kFlagLoadAsComponent);
   }
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
   }
 
-  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");
   }
 
   static KeyedService* CreateNetworkingPrivateServiceClient(
       content::BrowserContext* profile) {
     return new NetworkingPrivateServiceClient(new wifi::FakeWiFiService(),
                                               new CryptoVerifyStub());
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     ExtensionApiTest::SetUpOnMainThread();
     content::RunAllPendingInMessageLoop();
     NetworkingPrivateServiceClientFactory::GetInstance()->SetTestingFactory(
         profile(), &CreateNetworkingPrivateServiceClient);
   }
 
  protected:
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateServiceClientApiTest);
 };
 
@@ skipping 101 matching lines @@
                        VerifyAndEncryptCredentials) {
   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptCredentials")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateServiceClientApiTest,
                        VerifyAndEncryptData) {
   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptData")) << message_;
 }
 
 }  // namespace