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

chrome/browser/chromeos/file_manager/file_manager_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.
 
 // Browser test for basic Chrome OS file manager functionality:
 //  - The file list is updated when a file is added externally to the Downloads
 //    folder.
 //  - Selecting a file and copy-pasting it with the keyboard copies the file.
 //  - Selecting a file and pressing delete deletes it.
 
@@ skipping 259 matching lines @@
   }
 
   std::map<base::FilePath, const TestEntryInfo> entries_;
 };
 
 class DownloadsTestVolume : public LocalTestVolume {
  public:
   DownloadsTestVolume() : LocalTestVolume("Downloads") {}
   virtual ~DownloadsTestVolume() {}
 
-  virtual bool Mount(Profile* profile) OVERRIDE {
+  virtual bool Mount(Profile* profile) override {
     return CreateRootDirectory(profile) &&
            VolumeManager::Get(profile)
                ->RegisterDownloadsDirectoryForTesting(root_path());
   }
 };
 
 // Test volume for mimicing a specified type of volumes by a local folder.
 class FakeTestVolume : public LocalTestVolume {
  public:
   FakeTestVolume(const std::string& name,
@@ skipping 11 matching lines @@
     // Must be in sync with BASIC_FAKE_ENTRY_SET in the JS test code.
     CreateEntry(
         TestEntryInfo(FILE, "text.txt", "hello.txt", "text/plain", NONE,
                       base::Time::Now()));
     CreateEntry(
         TestEntryInfo(DIRECTORY, std::string(), "A", std::string(), NONE,
                       base::Time::Now()));
     return true;
   }
 
-  virtual bool Mount(Profile* profile) OVERRIDE {
+  virtual bool Mount(Profile* profile) override {
     if (!CreateRootDirectory(profile))
       return false;
     storage::ExternalMountPoints* const mount_points =
         storage::ExternalMountPoints::GetSystemInstance();
 
     // First revoke the existing mount point (if any).
     mount_points->RevokeFileSystem(name());
     const bool result =
         mount_points->RegisterFileSystem(name(),
                                          storage::kFileSystemTypeNativeLocal,
@@ skipping 175 matching lines @@
   Message GetNextMessage() {
     if (messages_.empty())
       content::RunMessageLoop();
     const Message entry = messages_.front();
     messages_.pop_front();
     return entry;
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     Message entry;
     entry.type = type;
     entry.message = type != extensions::NOTIFICATION_EXTENSION_TEST_PASSED
                         ? *content::Details<std::string>(details).ptr()
                         : std::string();
     entry.function =
         type == extensions::NOTIFICATION_EXTENSION_TEST_MESSAGE
             ? content::Source<extensions::TestSendMessageFunction>(source).ptr()
             : NULL;
     messages_.push_back(entry);
     base::MessageLoopForUI::current()->Quit();
   }
 
  private:
   std::deque<Message> messages_;
   content::NotificationRegistrar registrar_;
 };
 
 // The base test class.
 class FileManagerBrowserTestBase : public ExtensionApiTest {
  protected:
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
+  virtual void SetUpInProcessBrowserTestFixture() override;
 
-  virtual void SetUpOnMainThread() OVERRIDE;
+  virtual void SetUpOnMainThread() override;
 
   // Adds an incognito and guest-mode flags for tests in the guest mode.
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE;
+  virtual void SetUpCommandLine(CommandLine* command_line) override;
 
   // Loads our testing extension and sends it a string identifying the current
   // test.
   virtual void StartTest();
   void RunTestMessageLoop();
 
   // Overriding point for test configurations.
   virtual const char* GetTestManifestName() const {
     return "file_manager_test_manifest.json";
   }
@@ skipping 186 matching lines @@
 }
 
 // Parameter of FileManagerBrowserTest.
 // The second value is the case name of JavaScript.
 typedef std::tr1::tuple<GuestMode, const char*> TestParameter;
 
 // Test fixture class for normal (not multi-profile related) tests.
 class FileManagerBrowserTest :
       public FileManagerBrowserTestBase,
       public ::testing::WithParamInterface<TestParameter> {
-  virtual GuestMode GetGuestModeParam() const OVERRIDE {
+  virtual GuestMode GetGuestModeParam() const override {
     return std::tr1::get<0>(GetParam());
   }
-  virtual const char* GetTestCaseNameParam() const OVERRIDE {
+  virtual const char* GetTestCaseNameParam() const override {
     return std::tr1::get<1>(GetParam());
   }
 };
 
 IN_PROC_BROWSER_TEST_P(FileManagerBrowserTest, Test) {
   StartTest();
 }
 
 // Unlike TEST/TEST_F, which are macros that expand to further macros,
 // INSTANTIATE_TEST_CASE_P is a macro that expands directly to code that
@@ skipping 324 matching lines @@
   {"__dummy__@invalid.domain", "hashdummy", "Dummy Account"},
   {"alice@invalid.domain", "hashalice", "Alice"},
   {"bob@invalid.domain", "hashbob", "Bob"},
   {"charlie@invalid.domain", "hashcharlie", "Charlie"},
 };
 
 // Test fixture class for testing multi-profile features.
 class MultiProfileFileManagerBrowserTest : public FileManagerBrowserTestBase {
  protected:
   // Enables multi-profiles.
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     FileManagerBrowserTestBase::SetUpCommandLine(command_line);
     // Logs in to a dummy profile (For making MultiProfileWindowManager happy;
     // browser test creates a default window and the manager tries to assign a
     // user for it, and we need a profile connected to a user.)
     command_line->AppendSwitchASCII(chromeos::switches::kLoginUser,
                                     kTestAccounts[DUMMY_ACCOUNT_INDEX].email);
     command_line->AppendSwitchASCII(chromeos::switches::kLoginProfile,
                                     kTestAccounts[DUMMY_ACCOUNT_INDEX].hash);
   }
 
   // Logs in to the primary profile of this test.
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     const TestAccountInfo& info = kTestAccounts[PRIMARY_ACCOUNT_INDEX];
 
     AddUser(info, true);
     FileManagerBrowserTestBase::SetUpOnMainThread();
   }
 
   // Loads all users to the current session and sets up necessary fields.
   // This is used for preparing all accounts in PRE_ test setup, and for testing
   // actual login behavior.
   void AddAllUsers() {
     for (size_t i = 0; i < arraysize(kTestAccounts); ++i)
       AddUser(kTestAccounts[i], i >= SECONDARY_ACCOUNT_INDEX_START);
   }
 
   // Returns primary profile (if it is already created.)
-  virtual Profile* profile() OVERRIDE {
+  virtual Profile* profile() override {
     Profile* const profile = chromeos::ProfileHelper::GetProfileByUserIdHash(
         kTestAccounts[PRIMARY_ACCOUNT_INDEX].hash);
     return profile ? profile : FileManagerBrowserTestBase::profile();
   }
 
   // Sets the test case name (used as a function name in test_cases.js to call.)
   void set_test_case_name(const std::string& name) { test_case_name_ = name; }
 
   // Adds a new user for testing to the current session.
   void AddUser(const TestAccountInfo& info, bool log_in) {
     user_manager::UserManager* const user_manager =
         user_manager::UserManager::Get();
     if (log_in)
       user_manager->UserLoggedIn(info.email, info.hash, false);
     user_manager->SaveUserDisplayName(info.email,
                                       base::UTF8ToUTF16(info.display_name));
     chromeos::ProfileHelper::GetProfileByUserIdHash(info.hash)->GetPrefs()->
         SetString(prefs::kGoogleServicesUsername, info.email);
   }
 
  private:
-  virtual GuestMode GetGuestModeParam() const OVERRIDE {
+  virtual GuestMode GetGuestModeParam() const override {
     return NOT_IN_GUEST_MODE;
   }
 
-  virtual const char* GetTestCaseNameParam() const OVERRIDE {
+  virtual const char* GetTestCaseNameParam() const override {
     return test_case_name_.c_str();
   }
 
   virtual std::string OnMessage(const std::string& name,
-                                const base::Value* value) OVERRIDE {
+                                const base::Value* value) override {
     if (name == "addAllUsers") {
       AddAllUsers();
       return "true";
     } else if (name == "getWindowOwnerId") {
       chrome::MultiUserWindowManager* const window_manager =
           chrome::MultiUserWindowManager::GetInstance();
       extensions::AppWindowRegistry* const app_window_registry =
           extensions::AppWindowRegistry::Get(profile());
       DCHECK(window_manager);
       DCHECK(app_window_registry);
@@ skipping 50 matching lines @@
   AddAllUsers();
 
   // Sanity check that normal operations work in multi-profile setting as well.
   set_test_case_name("keyboardCopyDrive");
   StartTest();
 }
 
 template<GuestMode M>
 class GalleryBrowserTestBase : public FileManagerBrowserTestBase {
  public:
-  virtual GuestMode GetGuestModeParam() const OVERRIDE { return M; }
-  virtual const char* GetTestCaseNameParam() const OVERRIDE {
+  virtual GuestMode GetGuestModeParam() const override { return M; }
+  virtual const char* GetTestCaseNameParam() const override {
     return test_case_name_.c_str();
   }
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AddScript("common/test_util_common.js");
     AddScript("gallery/test_util.js");
     FileManagerBrowserTestBase::SetUp();
   }
 
   virtual std::string OnMessage(const std::string& name,
-                                const base::Value* value) OVERRIDE;
+                                const base::Value* value) override;
 
-  virtual const char* GetTestManifestName() const OVERRIDE {
+  virtual const char* GetTestManifestName() const override {
     return "gallery_test_manifest.json";
   }
 
   void AddScript(const std::string& name) {
     scripts_.AppendString(
         "chrome-extension://ejhcmmdhhpdhhgmifplfmjobgegbibkn/" + name);
   }
 
   void set_test_case_name(const std::string& name) {
     test_case_name_ = name;
@@ skipping 166 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, ExposureImageOnDrive) {
   AddScript("gallery/photo_editor.js");
   set_test_case_name("exposureImageOnDrive");
   StartTest();
 }
 
 template<GuestMode M>
 class VideoPlayerBrowserTestBase : public FileManagerBrowserTestBase {
  public:
-  virtual GuestMode GetGuestModeParam() const OVERRIDE { return M; }
-  virtual const char* GetTestCaseNameParam() const OVERRIDE {
+  virtual GuestMode GetGuestModeParam() const override { return M; }
+  virtual const char* GetTestCaseNameParam() const override {
     return test_case_name_.c_str();
   }
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AddScript("common/test_util_common.js");
     AddScript("video_player/test_util.js");
     FileManagerBrowserTestBase::SetUp();
   }
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(
         chromeos::switches::kEnableVideoPlayerChromecastSupport);
     FileManagerBrowserTestBase::SetUpCommandLine(command_line);
   }
 
   virtual std::string OnMessage(const std::string& name,
-                                const base::Value* value) OVERRIDE;
+                                const base::Value* value) override;
 
-  virtual const char* GetTestManifestName() const OVERRIDE {
+  virtual const char* GetTestManifestName() const override {
     return "video_player_test_manifest.json";
   }
 
   void AddScript(const std::string& name) {
     scripts_.AppendString(
         "chrome-extension://ljoplibgfehghmibaoaepfagnmbbfiga/" + name);
   }
 
   void set_test_case_name(const std::string& name) {
     test_case_name_ = name;
@@ skipping 26 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(VideoPlayerBrowserTest, OpenSingleVideoOnDrive) {
   AddScript("video_player/open_video_files.js");
   set_test_case_name("openSingleVideoOnDrive");
   StartTest();
 }
 
 }  // namespace
 }  // namespace file_manager