Update {virtual,override,final} to follow C++11 style in chrome/browser/chromeos/login.

chrome/browser/chromeos/login/kiosk_browsertest.cc

 // Copyright (c) 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 "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_controller_observer.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
@@ skipping 246 matching lines @@
   const std::string js_;
   scoped_refptr<content::MessageLoopRunner> runner_;
 
   DISALLOW_COPY_AND_ASSIGN(JsConditionWaiter);
 };
 
 class KioskFakeDiskMountManager : public file_manager::FakeDiskMountManager {
  public:
   KioskFakeDiskMountManager() {}
 
-  virtual ~KioskFakeDiskMountManager() {}
+  ~KioskFakeDiskMountManager() override {}
 
   void set_usb_mount_path(const std::string& usb_mount_path) {
     usb_mount_path_ = usb_mount_path;
   }
 
   void MountUsbStick() {
     DCHECK(!usb_mount_path_.empty());
     MountPath(usb_mount_path_, "", "", chromeos::MOUNT_TYPE_DEVICE);
   }
 
@@ skipping 12 matching lines @@
 
 }  // namespace
 
 class KioskTest : public OobeBaseTest {
  public:
   KioskTest() : use_consumer_kiosk_mode_(true),
                 fake_cws_(new FakeCWS) {
     set_exit_when_last_browser_closes(false);
   }
 
-  virtual ~KioskTest() {}
+  ~KioskTest() override {}
 
  protected:
-  virtual void SetUp() override {
+  void SetUp() override {
     test_app_id_ = kTestKioskApp;
     set_test_app_version("1.0.0");
     set_test_crx_file(test_app_id() + ".crx");
     needs_background_networking_ = true;
     mock_user_manager_.reset(new MockUserManager);
     ProfileHelper::SetAlwaysReturnPrimaryUserForTesting(true);
     AppLaunchController::SkipSplashWaitForTesting();
     AppLaunchController::SetNetworkWaitForTesting(kTestNetworkTimeoutSeconds);
 
     OobeBaseTest::SetUp();
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     ProfileHelper::SetAlwaysReturnPrimaryUserForTesting(false);
     OobeBaseTest::TearDown();
   }
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     OobeBaseTest::SetUpOnMainThread();
     // Needed to avoid showing Gaia screen instead of owner signin for
     // consumer network down test cases.
     StartupUtils::MarkDeviceRegistered(base::Closure());
   }
 
-  virtual void TearDownOnMainThread() override {
+  void TearDownOnMainThread() override {
     AppLaunchController::SetNetworkTimeoutCallbackForTesting(NULL);
     AppLaunchSigninScreen::SetUserManagerForTesting(NULL);
 
     OobeBaseTest::TearDownOnMainThread();
 
     // Clean up while main thread still runs.
     // See http://crbug.com/176659.
     KioskAppManager::Get()->CleanUp();
   }
 
-  virtual void SetUpCommandLine(base::CommandLine* command_line) override {
+  void SetUpCommandLine(base::CommandLine* command_line) override {
     OobeBaseTest::SetUpCommandLine(command_line);
     fake_cws_->Init(embedded_test_server());
   }
 
   void LaunchApp(const std::string& app_id, bool diagnostic_mode) {
     bool new_kiosk_ui = KioskAppMenuHandler::EnableNewKioskUI();
     GetLoginUI()->CallJavascriptFunction(new_kiosk_ui ?
         kLaunchAppForTestNewAPI : kLaunchAppForTestOldAPI,
         base::StringValue(app_id),
         base::FundamentalValue(diagnostic_mode));
@@ skipping 717 matching lines @@
   // Make cros settings untrusted.
   MakeCrosSettingsPermanentlyUntrusted();
 
   // Check that the attempt to auto-launch a kiosk app fails with an error.
   OobeScreenWaiter(OobeDisplay::SCREEN_ERROR_MESSAGE).Wait();
 }
 
 class KioskUpdateTest : public KioskTest {
  public:
   KioskUpdateTest() {}
-  virtual ~KioskUpdateTest() {}
+  ~KioskUpdateTest() override {}
 
  protected:
-  virtual void SetUp() override {
+  void SetUp() override {
     fake_disk_mount_manager_ = new KioskFakeDiskMountManager();
     disks::DiskMountManager::InitializeForTesting(fake_disk_mount_manager_);
 
     KioskTest::SetUp();
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     disks::DiskMountManager::Shutdown();
 
     KioskTest::TearDown();
   }
 
-  virtual void SetUpOnMainThread() override {
-    KioskTest::SetUpOnMainThread();
-  }
+  void SetUpOnMainThread() override { KioskTest::SetUpOnMainThread(); }
 
   void PreCacheApp(const std::string& app_id,
                    const std::string& version,
                    const std::string& crx_file) {
     set_test_app_id(app_id);
     set_test_app_version(version);
     set_test_crx_file(crx_file);
 
     KioskAppManager* manager = KioskAppManager::Get();
     AppDataLoadWaiter waiter(manager, app_id, version);
@@ skipping 63 matching lines @@
                                  const std::string& app_id)
         : runner_(NULL),
           manager_(manager),
           app_id_(app_id),
           quit_(false),
           update_success_(false),
           app_update_notified_(false) {
       manager_->AddObserver(this);
     }
 
-    virtual ~KioskAppExternalUpdateWaiter() { manager_->RemoveObserver(this); }
+    ~KioskAppExternalUpdateWaiter() override { manager_->RemoveObserver(this); }
 
     void Wait() {
       if (quit_)
         return;
       runner_ = new content::MessageLoopRunner;
       runner_->Run();
     }
 
     bool update_success() const { return update_success_; }
 
     bool app_update_notified() const { return app_update_notified_; }
 
    private:
     // KioskAppManagerObserver overrides:
-    virtual void OnKioskAppCacheUpdated(const std::string& app_id) override {
+    void OnKioskAppCacheUpdated(const std::string& app_id) override {
       if (app_id_ != app_id)
         return;
       app_update_notified_ = true;
     }
 
-    virtual void OnKioskAppExternalUpdateComplete(bool success) override {
+    void OnKioskAppExternalUpdateComplete(bool success) override {
       quit_ = true;
       update_success_ = success;
       if (runner_.get())
         runner_->Quit();
     }
 
     scoped_refptr<content::MessageLoopRunner> runner_;
     KioskAppManager* manager_;
     const std::string app_id_;
     bool quit_;
@@ skipping 10 matching lines @@
                       const std::string& version)
         : runner_(NULL),
           manager_(manager),
           loaded_(false),
           quit_(false),
           app_id_(app_id),
           version_(version) {
       manager_->AddObserver(this);
     }
 
-    virtual ~AppDataLoadWaiter() { manager_->RemoveObserver(this); }
+    ~AppDataLoadWaiter() override { manager_->RemoveObserver(this); }
 
     void Wait() {
       if (quit_)
         return;
       runner_ = new content::MessageLoopRunner;
       runner_->Run();
     }
 
     bool loaded() const { return loaded_; }
 
    private:
     // KioskAppManagerObserver overrides:
-    virtual void OnKioskExtensionLoadedInCache(
-        const std::string& app_id) override {
+    void OnKioskExtensionLoadedInCache(const std::string& app_id) override {
       std::string cached_version;
       base::FilePath file_path;
       if (!manager_->GetCachedCrx(app_id_, &file_path, &cached_version))
         return;
       if (version_ != cached_version)
         return;
       loaded_ = true;
       quit_ = true;
       if (runner_.get())
         runner_->Quit();
     }
 
-    virtual void OnKioskExtensionDownloadFailed(
-        const std::string& app_id) override {
+    void OnKioskExtensionDownloadFailed(const std::string& app_id) override {
       loaded_ = false;
       quit_ = true;
       if (runner_.get())
         runner_->Quit();
     }
 
     scoped_refptr<content::MessageLoopRunner> runner_;
     KioskAppManager* manager_;
     bool loaded_;
     bool quit_;
@@ skipping 315 matching lines @@
   EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 class KioskEnterpriseTest : public KioskTest {
  protected:
   KioskEnterpriseTest() {
     set_use_consumer_kiosk_mode(false);
   }
 
-  virtual void SetUpInProcessBrowserTestFixture() override {
+  void SetUpInProcessBrowserTestFixture() override {
     device_policy_test_helper_.MarkAsEnterpriseOwned();
     device_policy_test_helper_.InstallOwnerKey();
 
     KioskTest::SetUpInProcessBrowserTestFixture();
   }
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     KioskTest::SetUpOnMainThread();
 
     // Configure OAuth authentication.
     GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
 
     // This token satisfies the userinfo.email request from
     // DeviceOAuth2TokenService used in token validation.
     FakeGaia::AccessTokenInfo userinfo_token_info;
     userinfo_token_info.token = kTestUserinfoToken;
     userinfo_token_info.scopes.insert(
@@ skipping 153 matching lines @@
 }
 
 // Specialized test fixture for testing kiosk mode on the
 // hidden WebUI initialization flow for slow hardware.
 class KioskHiddenWebUITest : public KioskTest,
                              public ash::DesktopBackgroundControllerObserver {
  public:
   KioskHiddenWebUITest() : wallpaper_loaded_(false) {}
 
   // KioskTest overrides:
-  virtual void SetUpCommandLine(base::CommandLine* command_line) override {
+  void SetUpCommandLine(base::CommandLine* command_line) override {
     KioskTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kDisableBootAnimation);
   }
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     KioskTest::SetUpOnMainThread();
     ash::Shell::GetInstance()->desktop_background_controller()
         ->AddObserver(this);
   }
 
-  virtual void TearDownOnMainThread() override {
+  void TearDownOnMainThread() override {
     ash::Shell::GetInstance()->desktop_background_controller()
         ->RemoveObserver(this);
     KioskTest::TearDownOnMainThread();
   }
 
   void WaitForWallpaper() {
     if (!wallpaper_loaded_) {
       runner_ = new content::MessageLoopRunner;
       runner_->Run();
     }
   }
 
   bool wallpaper_loaded() const { return wallpaper_loaded_; }
 
   // ash::DesktopBackgroundControllerObserver overrides:
-  virtual void OnWallpaperDataChanged() override {
+  void OnWallpaperDataChanged() override {
     wallpaper_loaded_ = true;
     if (runner_.get())
       runner_->Quit();
   }
 
   bool wallpaper_loaded_;
   scoped_refptr<content::MessageLoopRunner> runner_;
 
   DISALLOW_COPY_AND_ASSIGN(KioskHiddenWebUITest);
 };
@@ skipping 24 matching lines @@
   content::WindowedNotificationObserver(
       chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_VISIBLE,
       content::NotificationService::AllSources()).Wait();
 
   // Wait for the wallpaper to load.
   WaitForWallpaper();
   EXPECT_TRUE(wallpaper_loaded());
 }
 
 }  // namespace chromeos