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

chrome/browser/chromeos/login/existing_user_controller_browsertest.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/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 76 matching lines @@
       : mock_login_display_(NULL), mock_user_manager_(NULL) {}
 
   ExistingUserController* existing_user_controller() {
     return ExistingUserController::current_controller();
   }
 
   const ExistingUserController* existing_user_controller() const {
     return ExistingUserController::current_controller();
   }
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
     SetUpSessionManager();
 
     DevicePolicyCrosBrowserTest::SetUpInProcessBrowserTestFixture();
 
     mock_login_utils_ = new MockLoginUtils();
     LoginUtils::Set(mock_login_utils_);
     EXPECT_CALL(*mock_login_utils_, DelegateDeleted(_))
         .Times(1);
 
     mock_login_display_host_.reset(new MockLoginDisplayHost());
@@ skipping 10 matching lines @@
         .WillOnce(Return(mock_login_display_));
     EXPECT_CALL(*mock_login_display_host_.get(), GetNativeWindow())
         .Times(1)
         .WillOnce(ReturnNull());
     EXPECT_CALL(*mock_login_display_host_.get(), OnPreferencesChanged())
         .Times(1);
     EXPECT_CALL(*mock_login_display_, Init(_, false, true, true))
         .Times(1);
   }
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kLoginManager);
   }
 
   virtual void SetUpUserManager() {
     // Replace the UserManager singleton with a mock.
     mock_user_manager_ = new MockUserManager;
     user_manager_enabler_.reset(
         new ScopedUserManagerEnabler(mock_user_manager_));
     EXPECT_CALL(*mock_user_manager_, IsKnownUser(kUsername))
         .Times(AnyNumber())
@@ skipping 16 matching lines @@
     EXPECT_CALL(*mock_user_manager_, IsSessionStarted())
         .Times(AnyNumber())
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*mock_user_manager_, IsCurrentUserNew())
         .Times(AnyNumber())
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*mock_user_manager_, Shutdown())
         .Times(1);
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     testing_profile_.reset(new TestingProfile());
     SetUpUserManager();
     existing_user_controller_.reset(
         new ExistingUserController(mock_login_display_host_.get()));
     ASSERT_EQ(existing_user_controller(), existing_user_controller_.get());
     existing_user_controller_->Init(user_manager::UserList());
     profile_prepared_cb_ =
         base::Bind(&ExistingUserController::OnProfilePrepared,
                    base::Unretained(existing_user_controller()),
                    testing_profile_.get());
   }
 
-  virtual void TearDownOnMainThread() OVERRIDE {
+  virtual void TearDownOnMainThread() override {
     // ExistingUserController must be deleted before the thread is cleaned up:
     // If there is an outstanding login attempt when ExistingUserController is
     // deleted, its LoginPerformer instance will be deleted, which in turn
     // deletes its OnlineAttemptHost instance.  However, OnlineAttemptHost must
     // be deleted on the UI thread.
     existing_user_controller_.reset();
     DevicePolicyCrosBrowserTest::InProcessBrowserTest::TearDownOnMainThread();
     testing_profile_.reset(NULL);
     user_manager_enabler_.reset();
   }
@@ skipping 151 matching lines @@
 
 class ExistingUserControllerPublicSessionTest
     : public ExistingUserControllerTest {
  protected:
   ExistingUserControllerPublicSessionTest()
       : public_session_user_id_(policy::GenerateDeviceLocalAccountUserId(
             kPublicSessionAccountId,
             policy::DeviceLocalAccount::TYPE_PUBLIC_SESSION)) {
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     ExistingUserControllerTest::SetUpOnMainThread();
 
     // Wait for the public session user to be created.
     if (!user_manager::UserManager::Get()->IsKnownUser(
             public_session_user_id_)) {
       content::WindowedNotificationObserver(
           chrome::NOTIFICATION_USER_LIST_CHANGED,
           base::Bind(&user_manager::UserManager::IsKnownUser,
                      base::Unretained(user_manager::UserManager::Get()),
                      public_session_user_id_)).Wait();
@@ skipping 14 matching lines @@
       base::RunLoop loop;
       store->AddObserver(&observer);
       EXPECT_CALL(observer, OnStoreLoaded(store))
           .Times(1)
           .WillOnce(InvokeWithoutArgs(&loop, &base::RunLoop::Quit));
       loop.Run();
       store->RemoveObserver(&observer);
     }
   }
 
-  virtual void SetUpSessionManager() OVERRIDE {
+  virtual void SetUpSessionManager() override {
     InstallOwnerKey();
 
     // Setup the device policy.
     em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
     em::DeviceLocalAccountInfoProto* account =
         proto.mutable_device_local_accounts()->add_account();
     account->set_account_id(kPublicSessionAccountId);
     account->set_type(
         em::DeviceLocalAccountInfoProto::ACCOUNT_TYPE_PUBLIC_SESSION);
     RefreshDevicePolicy();
 
     // Setup the device local account policy.
     policy::UserPolicyBuilder device_local_account_policy;
     device_local_account_policy.policy_data().set_username(
         kPublicSessionAccountId);
     device_local_account_policy.policy_data().set_policy_type(
         policy::dm_protocol::kChromePublicAccountPolicyType);
     device_local_account_policy.policy_data().set_settings_entity_id(
         kPublicSessionAccountId);
     device_local_account_policy.Build();
     session_manager_client()->set_device_local_account_policy(
         kPublicSessionAccountId,
         device_local_account_policy.GetBlob());
   }
 
-  virtual void SetUpLoginDisplay() OVERRIDE {
+  virtual void SetUpLoginDisplay() override {
     EXPECT_CALL(*mock_login_display_host_.get(), CreateLoginDisplay(_))
         .Times(1)
         .WillOnce(Return(mock_login_display_));
     EXPECT_CALL(*mock_login_display_host_.get(), GetNativeWindow())
       .Times(AnyNumber())
       .WillRepeatedly(ReturnNull());
     EXPECT_CALL(*mock_login_display_host_.get(), OnPreferencesChanged())
       .Times(AnyNumber());
     EXPECT_CALL(*mock_login_display_, Init(_, _, _, _))
       .Times(AnyNumber());
   }
 
-  virtual void SetUpUserManager() OVERRIDE {
+  virtual void SetUpUserManager() override {
   }
 
   void ExpectSuccessfulLogin(const UserContext& user_context) {
     EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
         .Times(AnyNumber());
     EXPECT_CALL(*mock_login_utils_, CreateAuthenticator(_))
         .Times(1)
         .WillOnce(WithArg<0>(CreateAuthenticator(user_context)));
     EXPECT_CALL(*mock_login_utils_, PrepareProfile(user_context, _, _, _))
         .Times(1)
@@ skipping 245 matching lines @@
   // First run propagates public accounts and stores them in Local State.
 }
 
 // See http://crbug.com/393704; flaky.
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        DISABLED_TestLoadingPublicUsersFromLocalState) {
   // Second run loads list of public accounts from Local State.
 }
 
 }  // namespace chromeos