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

chrome/browser/chromeos/login/wizard_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 "chrome/browser/chromeos/login/wizard_controller.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_registry_simple.h"
@@ skipping 97 matching lines @@
 const char kDisabledMessage[] = "This device has been disabled.";
 
 // Matches on the mode parameter of an EnrollmentConfig object.
 MATCHER_P(EnrollmentModeMatches, mode, "") {
   return arg.mode == mode;
 }
 
 class PrefStoreStub : public TestingPrefStore {
  public:
   // TestingPrefStore overrides:
-  virtual PrefReadError GetReadError() const override {
+  PrefReadError GetReadError() const override {
     return PersistentPrefStore::PREF_READ_ERROR_JSON_PARSE;
   }
 
-  virtual bool IsInitializationComplete() const override {
-    return true;
-  }
+  bool IsInitializationComplete() const override { return true; }
 
  private:
-  virtual ~PrefStoreStub() {}
+  ~PrefStoreStub() override {}
 };
 
 struct SwitchLanguageTestData {
   SwitchLanguageTestData() : result("", "", false), done(false) {}
 
   locale_util::LanguageSwitchResult result;
   bool done;
 };
 
 void OnLocaleSwitched(SwitchLanguageTestData* self,
@@ skipping 99 matching lines @@
       new actor_class);                                                      \
   WizardController::default_controller()                                     \
       ->screens_[WizardController::screen_name] = make_linked_ptr(mock_var); \
   EXPECT_CALL(*mock_var, Show()).Times(0);                                   \
   EXPECT_CALL(*mock_var, Hide()).Times(0);
 
 class WizardControllerTest : public WizardInProcessBrowserTest {
  protected:
   WizardControllerTest() : WizardInProcessBrowserTest(
       WizardController::kTestNoScreenName) {}
-  virtual ~WizardControllerTest() {}
+  ~WizardControllerTest() override {}
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     AccessibilityManager::Get()->
         SetProfileForTest(ProfileHelper::GetSigninProfile());
     WizardInProcessBrowserTest::SetUpOnMainThread();
   }
 
   ErrorScreen* GetErrorScreen() {
     return static_cast<BaseScreenDelegate*>(
                WizardController::default_controller())->GetErrorScreen();
   }
 
@@ skipping 108 matching lines @@
   // Check that output is unmuted now and at some level.
   CrasAudioHandler* cras = CrasAudioHandler::Get();
   ASSERT_FALSE(cras->IsOutputMuted());
   ASSERT_EQ(WizardController::kMinAudibleOutputVolumePercent,
             cras->GetOutputVolumePercent());
 }
 
 class WizardControllerTestURLFetcherFactory
     : public net::TestURLFetcherFactory {
  public:
-  virtual net::URLFetcher* CreateURLFetcher(
-      int id,
-      const GURL& url,
-      net::URLFetcher::RequestType request_type,
-      net::URLFetcherDelegate* d) override {
+  net::URLFetcher* CreateURLFetcher(int id,
+                                    const GURL& url,
+                                    net::URLFetcher::RequestType request_type,
+                                    net::URLFetcherDelegate* d) override {
     if (StartsWithASCII(
             url.spec(),
             SimpleGeolocationProvider::DefaultGeolocationProviderURL().spec(),
             true)) {
       return new net::FakeURLFetcher(url,
                                      d,
                                      std::string(kGeolocationResponseBody),
                                      net::HTTP_OK,
                                      net::URLRequestStatus::SUCCESS);
     }
     if (StartsWithASCII(url.spec(),
                         chromeos::DefaultTimezoneProviderURL().spec(),
                         true)) {
       return new net::FakeURLFetcher(url,
                                      d,
                                      std::string(kTimezoneResponseBody),
                                      net::HTTP_OK,
                                      net::URLRequestStatus::SUCCESS);
     }
     return net::TestURLFetcherFactory::CreateURLFetcher(
         id, url, request_type, d);
   }
-  virtual ~WizardControllerTestURLFetcherFactory() {}
+  ~WizardControllerTestURLFetcherFactory() override {}
 };
 
 class TimeZoneTestRunner {
  public:
   void OnResolved() { loop_.Quit(); }
   void Run() { loop_.Run(); }
 
  private:
   base::RunLoop loop_;
 };
 
 class WizardControllerFlowTest : public WizardControllerTest {
  protected:
   WizardControllerFlowTest() {}
   // Overriden from InProcessBrowserTest:
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     WizardControllerTest::SetUpOnMainThread();
 
     // Make sure that OOBE is run as an "official" build.
     WizardController* wizard_controller =
         WizardController::default_controller();
     wizard_controller->is_official_build_ = true;
 
     // Clear portal list (as it is by default in OOBE).
     NetworkHandler::Get()->network_state_handler()->SetCheckPortalList("");
 
@@ skipping 39 matching lines @@
     EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
     wizard_controller->AdvanceToScreen(WizardController::kNetworkScreenName);
   }
 
   void TearDownOnMainThread() override {
     mock_network_screen_.reset();
     device_disabled_screen_actor_.reset();
     WizardControllerTest::TearDownOnMainThread();
   }
 
-  virtual void TearDown() {
+  void TearDown() override {
     if (fallback_fetcher_factory_) {
       fetcher_factory_.reset();
       net::URLFetcherImpl::set_factory(fallback_fetcher_factory_.get());
       fallback_fetcher_factory_.reset();
     }
   }
 
   void InitTimezoneResolver() {
     fallback_fetcher_factory_.reset(new WizardControllerTestURLFetcherFactory);
     net::URLFetcherImpl::set_factory(NULL);
@@ skipping 243 matching lines @@
   WizardControllerDeviceStateTest()
       : install_attributes_(std::string(),
                             std::string(),
                             std::string(),
                             policy::DEVICE_MODE_NOT_SET) {
     fake_statistics_provider_.SetMachineStatistic("serial_number", "test");
     fake_statistics_provider_.SetMachineStatistic(system::kActivateDateKey,
                                                   "2000-01");
   }
 
-  virtual void SetUpCommandLine(base::CommandLine* command_line) override {
+  void SetUpCommandLine(base::CommandLine* command_line) override {
     WizardControllerFlowTest::SetUpCommandLine(command_line);
 
     command_line->AppendSwitchASCII(
         switches::kEnterpriseEnableForcedReEnrollment,
         chromeos::AutoEnrollmentController::kForcedReEnrollmentAlways);
     command_line->AppendSwitchASCII(
         switches::kEnterpriseEnrollmentInitialModulus, "1");
     command_line->AppendSwitchASCII(
         switches::kEnterpriseEnrollmentModulusLimit, "2");
   }
@@ skipping 148 matching lines @@
 
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 }
 
 class WizardControllerBrokenLocalStateTest : public WizardControllerTest {
  protected:
   WizardControllerBrokenLocalStateTest()
       : fake_session_manager_client_(NULL) {
   }
 
-  virtual ~WizardControllerBrokenLocalStateTest() {}
+  ~WizardControllerBrokenLocalStateTest() override {}
 
-  virtual void SetUpInProcessBrowserTestFixture() override {
+  void SetUpInProcessBrowserTestFixture() override {
     WizardControllerTest::SetUpInProcessBrowserTestFixture();
 
     fake_session_manager_client_ = new FakeSessionManagerClient;
     DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
         scoped_ptr<SessionManagerClient>(fake_session_manager_client_));
   }
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     base::PrefServiceFactory factory;
     factory.set_user_prefs(make_scoped_refptr(new PrefStoreStub()));
     local_state_ = factory.Create(new PrefRegistrySimple()).Pass();
     WizardController::set_local_state_for_testing(local_state_.get());
 
     WizardControllerTest::SetUpOnMainThread();
 
     // Make sure that OOBE is run as an "official" build.
     WizardController::default_controller()->is_official_build_ = true;
   }
@@ skipping 35 matching lines @@
   ASSERT_EQ(1, fake_session_manager_client()->start_device_wipe_call_count());
 }
 
 class WizardControllerProxyAuthOnSigninTest : public WizardControllerTest {
  protected:
   WizardControllerProxyAuthOnSigninTest()
       : proxy_server_(net::SpawnedTestServer::TYPE_BASIC_AUTH_PROXY,
                       net::SpawnedTestServer::kLocalhost,
                       base::FilePath()) {
   }
-  virtual ~WizardControllerProxyAuthOnSigninTest() {}
+  ~WizardControllerProxyAuthOnSigninTest() override {}
 
   // Overridden from WizardControllerTest:
-  virtual void SetUp() override {
+  void SetUp() override {
     ASSERT_TRUE(proxy_server_.Start());
     WizardControllerTest::SetUp();
   }
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     WizardControllerTest::SetUpOnMainThread();
     WizardController::default_controller()->AdvanceToScreen(
         WizardController::kNetworkScreenName);
   }
 
-  virtual void SetUpCommandLine(base::CommandLine* command_line) override {
+  void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitchASCII(::switches::kProxyServer,
                                     proxy_server_.host_port_pair().ToString());
   }
 
   net::SpawnedTestServer& proxy_server() { return proxy_server_; }
 
  private:
   net::SpawnedTestServer proxy_server_;
 
   DISALLOW_COPY_AND_ASSIGN(WizardControllerProxyAuthOnSigninTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerProxyAuthOnSigninTest,
                        ProxyAuthDialogOnSigninScreen) {
   content::WindowedNotificationObserver auth_needed_waiter(
       chrome::NOTIFICATION_AUTH_NEEDED,
       content::NotificationService::AllSources());
 
   CheckCurrentScreen(WizardController::kNetworkScreenName);
 
   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
   auth_needed_waiter.Wait();
 }
 
 class WizardControllerKioskFlowTest : public WizardControllerFlowTest {
  protected:
   WizardControllerKioskFlowTest() {}
 
   // Overridden from InProcessBrowserTest:
-  virtual void SetUpCommandLine(base::CommandLine* command_line) override {
+  void SetUpCommandLine(base::CommandLine* command_line) override {
     base::FilePath test_data_dir;
     ASSERT_TRUE(chromeos::test_utils::GetTestDataPath(
                     "app_mode", "kiosk_manifest", &test_data_dir));
     command_line->AppendSwitchPath(
         switches::kAppOemManifestFile,
         test_data_dir.AppendASCII("kiosk_manifest.json"));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WizardControllerKioskFlowTest);
@@ skipping 86 matching lines @@
   CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 }
 
 
 class WizardControllerEnableDebuggingTest : public WizardControllerFlowTest {
  protected:
   WizardControllerEnableDebuggingTest() {}
 
   // Overridden from InProcessBrowserTest:
-  virtual void SetUpCommandLine(base::CommandLine* command_line) override {
+  void SetUpCommandLine(base::CommandLine* command_line) override {
     WizardControllerFlowTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(chromeos::switches::kSystemDevMode);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WizardControllerEnableDebuggingTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerEnableDebuggingTest,
                        ShowAndCancelEnableDebugging) {
@@ skipping 18 matching lines @@
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
   CheckCurrentScreen(WizardController::kNetworkScreenName);
 }
 
 class WizardControllerOobeResumeTest : public WizardControllerTest {
  protected:
   WizardControllerOobeResumeTest() {}
   // Overriden from InProcessBrowserTest:
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     WizardControllerTest::SetUpOnMainThread();
 
     // Make sure that OOBE is run as an "official" build.
     WizardController::default_controller()->is_official_build_ = true;
 
     // Clear portal list (as it is by default in OOBE).
     NetworkHandler::Get()->network_state_handler()->SetCheckPortalList("");
 
     // Set up the mocks for all screens.
     MOCK_WITH_DELEGATE(mock_network_screen_, kNetworkScreenName,
@@ skipping 53 matching lines @@
 // TODO(merkulova): Add tests for bluetooth HID detection screen variations when
 // UI and logic is ready. http://crbug.com/127016
 
 // TODO(dzhioev): Add tests for controller/host pairing flow.
 // http://crbug.com/375191
 
 static_assert(BaseScreenDelegate::EXIT_CODES_COUNT == 24,
               "tests for new control flow are missing");
 
 }  // namespace chromeos