replace OVERRIDE and FINAL with override and final in chrome/browser/extensions/

chrome/browser/extensions/api/networking_private/networking_private_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/extension_apitest.h"
@@ skipping 70 matching lines @@
  public:
   TestListener(const std::string& message, const base::Closure& callback)
       : message_(message), callback_(callback) {
     registrar_.Add(this,
                    extensions::NOTIFICATION_EXTENSION_TEST_MESSAGE,
                    content::NotificationService::AllSources());
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& /* source */,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     const std::string& message = *content::Details<std::string>(details).ptr();
     if (message == message_)
       callback_.Run();
   }
 
  private:
   std::string message_;
   base::Closure callback_;
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(TestListener);
 };
 #else  // !defined(OS_CHROMEOS)
 
 // Stub Verify* methods implementation to satisfy expectations of
 // networking_private_apitest.
 // TODO(mef): Fix ChromeOS implementation to use NetworkingPrivateCrypto,
 // and update networking_private_apitest to use and expect valid data.
 // That will eliminate the need for mock implementation.
 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";
   }
 };
 #endif  // defined(OS_CHROMEOS)
 
 class ExtensionNetworkingPrivateApiTest
     : public ExtensionApiTest {
  public:
   ExtensionNetworkingPrivateApiTest()
 #if defined(OS_CHROMEOS)
       : detector_(NULL),
         service_test_(NULL),
         manager_test_(NULL),
         device_test_(NULL)
 #endif
   {
   }
 
   bool RunNetworkingSubtest(const std::string& subtest) {
     return RunExtensionSubtest(
         "networking", "main.html?" + subtest,
         kFlagEnableFileAccess | kFlagLoadAsComponent);
   }
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
 #if defined(OS_CHROMEOS)
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
     policy::BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
 #endif
 
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
   }
 
 #if defined(OS_CHROMEOS)
   static void AssignString(std::string* out,
                            DBusMethodCallStatus call_status,
                            const std::string& result) {
     CHECK_EQ(call_status, DBUS_METHOD_CALL_SUCCESS);
     *out = result;
   }
 
-  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");
 
     // TODO(pneubeck): Remove the following hack, once the NetworkingPrivateAPI
     // uses the ProfileHelper to obtain the userhash crbug/238623.
     const std::string login_user = chromeos::login::CanonicalizeUserID(
         command_line->GetSwitchValueNative(chromeos::switches::kLoginUser));
@@ skipping 52 matching lines @@
 
   void AddService(const std::string& service_path,
                   const std::string& name,
                   const std::string& type,
                   const std::string& state) {
     service_test_->AddService(
         service_path, service_path + "_guid", name,
         type, state, true /* add_to_visible */);
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     detector_ = new NetworkPortalDetectorTestImpl();
     NetworkPortalDetector::InitializeForTesting(detector_);
 
     ExtensionApiTest::SetUpOnMainThread();
     content::RunAllPendingInMessageLoop();
 
     InitializeSanitizedUsername();
 
     DBusThreadManager* dbus_manager = DBusThreadManager::Get();
     manager_test_ = dbus_manager->GetShillManagerClient()->GetTestInterface();
@@ skipping 105 matching lines @@
     service_test_->SetServiceProperty("stub_wifi2",
                                       shill::kProfileProperty,
                                       base::StringValue(kUser1ProfilePath));
     profile_test->AddService(kUser1ProfilePath, "stub_wifi2");
 
     AddService("stub_vpn1", "vpn1", shill::kTypeVPN, shill::kStateOnline);
 
     content::RunAllPendingInMessageLoop();
   }
 #else  // !defined(OS_CHROMEOS)
-  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 extensions::NetworkingPrivateServiceClient(
         new wifi::FakeWiFiService(), new CryptoVerifyStub());
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     ExtensionApiTest::SetUpOnMainThread();
     content::RunAllPendingInMessageLoop();
     NetworkingPrivateServiceClientFactory::GetInstance()->SetTestingFactory(
         profile(),
         &CreateNetworkingPrivateServiceClient);
   }
 
 #endif  // OS_CHROMEOS
 
  protected:
@@ skipping 233 matching lines @@
 
   TestListener listener(
       "notifyPortalDetectorObservers",
       base::Bind(&NetworkPortalDetectorTestImpl::NotifyObserversForTesting,
                  base::Unretained(detector())));
   EXPECT_TRUE(RunNetworkingSubtest("captivePortalNotification")) << message_;
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace