replace OVERRIDE and FINAL with override and final in chrome/browser/ui/[a-s]*

chrome/browser/ui/ash/launcher/chrome_launcher_controller_unittest.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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 80 matching lines @@
   TestShelfModelObserver()
     : added_(0),
       removed_(0),
       changed_(0) {
   }
 
   virtual ~TestShelfModelObserver() {
   }
 
   // Overridden from ash::ShelfModelObserver:
-  virtual void ShelfItemAdded(int index) OVERRIDE {
+  virtual void ShelfItemAdded(int index) override {
     ++added_;
     last_index_ = index;
   }
 
-  virtual void ShelfItemRemoved(int index, ash::ShelfID id) OVERRIDE {
+  virtual void ShelfItemRemoved(int index, ash::ShelfID id) override {
     ++removed_;
     last_index_ = index;
   }
 
   virtual void ShelfItemChanged(int index,
-                                const ash::ShelfItem& old_item) OVERRIDE {
+                                const ash::ShelfItem& old_item) override {
     ++changed_;
     last_index_ = index;
   }
 
-  virtual void ShelfItemMoved(int start_index, int target_index) OVERRIDE {
+  virtual void ShelfItemMoved(int start_index, int target_index) override {
     last_index_ = target_index;
   }
 
-  virtual void ShelfStatusChanged() OVERRIDE {
+  virtual void ShelfStatusChanged() override {
   }
 
   void clear_counts() {
     added_ = 0;
     removed_ = 0;
     changed_ = 0;
     last_index_ = 0;
   }
 
   int added() const { return added_; }
@@ skipping 13 matching lines @@
 // Test implementation of AppIconLoader.
 class TestAppIconLoaderImpl : public extensions::AppIconLoader {
  public:
   TestAppIconLoaderImpl() : fetch_count_(0) {
   }
 
   virtual ~TestAppIconLoaderImpl() {
   }
 
   // AppIconLoader implementation:
-  virtual void FetchImage(const std::string& id) OVERRIDE {
+  virtual void FetchImage(const std::string& id) override {
     ++fetch_count_;
   }
 
-  virtual void ClearImage(const std::string& id) OVERRIDE {
+  virtual void ClearImage(const std::string& id) override {
   }
 
-  virtual void UpdateImage(const std::string& id) OVERRIDE {
+  virtual void UpdateImage(const std::string& id) override {
   }
 
   int fetch_count() const { return fetch_count_; }
 
  private:
   int fetch_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAppIconLoaderImpl);
 };
 
 // Test implementation of AppTabHelper.
 class TestAppTabHelperImpl : public ChromeLauncherController::AppTabHelper {
  public:
   TestAppTabHelperImpl() {}
   virtual ~TestAppTabHelperImpl() {}
 
   // Sets the id for the specified tab. The id is removed if Remove() is
   // invoked.
   void SetAppID(content::WebContents* tab, const std::string& id) {
     tab_id_map_[tab] = id;
   }
 
   // Returns true if there is an id registered for |tab|.
   bool HasAppID(content::WebContents* tab) const {
     return tab_id_map_.find(tab) != tab_id_map_.end();
   }
 
   // AppTabHelper implementation:
-  virtual std::string GetAppID(content::WebContents* tab) OVERRIDE {
+  virtual std::string GetAppID(content::WebContents* tab) override {
     return tab_id_map_.find(tab) != tab_id_map_.end() ? tab_id_map_[tab] :
         std::string();
   }
 
-  virtual bool IsValidIDForCurrentUser(const std::string& id) OVERRIDE {
+  virtual bool IsValidIDForCurrentUser(const std::string& id) override {
     for (TabToStringMap::const_iterator i = tab_id_map_.begin();
          i != tab_id_map_.end(); ++i) {
       if (i->second == id)
         return true;
     }
     return false;
   }
 
-  virtual void SetCurrentUser(Profile* profile) OVERRIDE {
+  virtual void SetCurrentUser(Profile* profile) override {
     // We can ignore this for now.
   }
 
  private:
   typedef std::map<content::WebContents*, std::string> TabToStringMap;
 
   TabToStringMap tab_id_map_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAppTabHelperImpl);
 };
 
 // Test implementation of a V2 app launcher item controller.
 class TestV2AppLauncherItemController : public LauncherItemController {
  public:
   TestV2AppLauncherItemController(const std::string& app_id,
                                   ChromeLauncherController* controller)
       : LauncherItemController(LauncherItemController::TYPE_APP,
                                app_id,
                                controller) {
   }
 
   virtual ~TestV2AppLauncherItemController() {}
 
   // Override for LauncherItemController:
-  virtual bool IsOpen() const OVERRIDE { return true; }
-  virtual bool IsVisible() const OVERRIDE { return true; }
-  virtual void Launch(ash::LaunchSource source, int event_flags) OVERRIDE {}
-  virtual bool Activate(ash::LaunchSource source) OVERRIDE { return false; }
-  virtual void Close() OVERRIDE {}
-  virtual bool ItemSelected(const ui::Event& event) OVERRIDE { return false; }
-  virtual base::string16 GetTitle() OVERRIDE { return base::string16(); }
+  virtual bool IsOpen() const override { return true; }
+  virtual bool IsVisible() const override { return true; }
+  virtual void Launch(ash::LaunchSource source, int event_flags) override {}
+  virtual bool Activate(ash::LaunchSource source) override { return false; }
+  virtual void Close() override {}
+  virtual bool ItemSelected(const ui::Event& event) override { return false; }
+  virtual base::string16 GetTitle() override { return base::string16(); }
   virtual ChromeLauncherAppMenuItems GetApplicationList(
-      int event_flags) OVERRIDE {
+      int event_flags) override {
     ChromeLauncherAppMenuItems items;
     items.push_back(
         new ChromeLauncherAppMenuItem(base::string16(), NULL, false));
     items.push_back(
         new ChromeLauncherAppMenuItem(base::string16(), NULL, false));
     return items.Pass();
   }
-  virtual ui::MenuModel* CreateContextMenu(aura::Window* root_window) OVERRIDE {
+  virtual ui::MenuModel* CreateContextMenu(aura::Window* root_window) override {
     return NULL;
   }
-  virtual ash::ShelfMenuModel* CreateApplicationMenu(int event_flags) OVERRIDE {
+  virtual ash::ShelfMenuModel* CreateApplicationMenu(int event_flags) override {
     return NULL;
   }
-  virtual bool IsDraggable() OVERRIDE { return false; }
-  virtual bool ShouldShowTooltip() OVERRIDE { return false; }
+  virtual bool IsDraggable() override { return false; }
+  virtual bool ShouldShowTooltip() override { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestV2AppLauncherItemController);
 };
 
 }  // namespace
 
 class ChromeLauncherControllerTest : public BrowserWithTestWindowTest {
  protected:
   ChromeLauncherControllerTest()
       : BrowserWithTestWindowTest(
             Browser::TYPE_TABBED,
             chrome::HOST_DESKTOP_TYPE_ASH,
             false),
         test_controller_(NULL),
         extension_service_(NULL) {
   }
 
   virtual ~ChromeLauncherControllerTest() {
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     BrowserWithTestWindowTest::SetUp();
 
     model_.reset(new ash::ShelfModel);
     model_observer_.reset(new TestShelfModelObserver);
     model_->AddObserver(model_observer_.get());
 
     if (ash::Shell::HasInstance()) {
       item_delegate_manager_ =
           ash::Shell::GetInstance()->shelf_item_delegate_manager();
     } else {
@@ skipping 118 matching lines @@
     InsertPrefValue(user_a, 2, extension3_->id());
     InsertPrefValue(user_a, 3, extension4_->id());
     InsertPrefValue(user_a, 4, extension5_->id());
     InsertPrefValue(user_a, 5, extension6_->id());
 
     // Set user b preferences.
     InsertPrefValue(user_b, 0, extension7_->id());
     InsertPrefValue(user_b, 1, extension8_->id());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (!ash::Shell::HasInstance())
       delete item_delegate_manager_;
     model_->RemoveObserver(model_observer_.get());
     model_observer_.reset();
     launcher_controller_.reset();
     model_.reset();
 
     BrowserWithTestWindowTest::TearDown();
   }
 
@@ skipping 198 matching lines @@
 // it.
 class TestBrowserWindowAura : public TestBrowserWindow {
  public:
   // |native_window| will still be owned by the caller after the constructor
   // was called.
   explicit TestBrowserWindowAura(aura::Window* native_window)
       : native_window_(native_window) {
   }
   virtual ~TestBrowserWindowAura() {}
 
-  virtual gfx::NativeWindow GetNativeWindow() OVERRIDE {
+  virtual gfx::NativeWindow GetNativeWindow() override {
     return native_window_.get();
   }
 
   Browser* browser() { return browser_.get(); }
 
   void CreateBrowser(const Browser::CreateParams& params) {
     Browser::CreateParams create_params = params;
     create_params.window = this;
     browser_.reset(new Browser(create_params));
   }
@@ skipping 32 matching lines @@
   }
   virtual ~WebContentsDestroyedWatcher() {}
 
   // Waits until the WebContents is destroyed.
   void Wait() {
     message_loop_runner_->Run();
   }
 
  private:
   // Overridden WebContentsObserver methods.
-  virtual void WebContentsDestroyed() OVERRIDE {
+  virtual void WebContentsDestroyed() override {
     message_loop_runner_->Quit();
   }
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsDestroyedWatcher);
 };
 
 // A V1 windowed application.
 class V1App : public TestBrowserWindow {
@@ skipping 20 matching lines @@
   }
 
   virtual ~V1App() {
     // close all tabs. Note that we do not need to destroy the browser itself.
     browser_->tab_strip_model()->CloseAllTabs();
   }
 
   Browser* browser() { return browser_.get(); }
 
   // TestBrowserWindow override:
-  virtual gfx::NativeWindow GetNativeWindow() OVERRIDE {
+  virtual gfx::NativeWindow GetNativeWindow() override {
     return native_window_.get();
   }
 
  private:
   // The associated browser with this app.
   scoped_ptr<Browser> browser_;
 
   // The native window we use.
   scoped_ptr<aura::Window> native_window_;
 
@@ skipping 36 matching lines @@
 class MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest
     : public ChromeLauncherControllerTest {
  protected:
   MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest() {
   }
 
   virtual ~MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest() {
   }
 
   // Overwrite the Setup function to enable multi profile and needed objects.
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     profile_manager_.reset(
         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
 
     ASSERT_TRUE(profile_manager_->SetUp());
 
     // AvatarMenu and multiple profiles works after user logged in.
     profile_manager_->SetLoggedIn(true);
 
     // Initialize the UserManager singleton to a fresh FakeUserManager instance.
     user_manager_enabler_.reset(
@@ skipping 101 matching lines @@
     return v1_app;
   }
 
   ash::test::TestSessionStateDelegate* session_delegate() {
     return static_cast<ash::test::TestSessionStateDelegate*>(
         ash::Shell::GetInstance()->session_state_delegate());
   }
   ash::test::TestShellDelegate* shell_delegate() { return shell_delegate_; }
 
   // Override BrowserWithTestWindowTest:
-  virtual TestingProfile* CreateProfile() OVERRIDE {
+  virtual TestingProfile* CreateProfile() override {
     return CreateMultiUserProfile("user1");
   }
-  virtual void DestroyProfile(TestingProfile* profile) OVERRIDE {
+  virtual void DestroyProfile(TestingProfile* profile) override {
     // Delete the profile through our profile manager.
     ProfileToNameMap::iterator it = created_profiles_.find(profile);
     DCHECK(it != created_profiles_.end());
     profile_manager_->DeleteTestingProfile(it->second);
     created_profiles_.erase(it);
   }
 
  private:
   typedef std::map<Profile*, std::string> ProfileToNameMap;
   TestingProfileManager* profile_manager() { return profile_manager_.get(); }
@@ skipping 1766 matching lines @@
 
   EXPECT_EQ(1, app_icon_loader->fetch_count());
   ASSERT_EQ(initial_size + 1, model_->items().size());
   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[app_index].type);
 
   launcher_controller_->UnpinAppWithID("1");
   ASSERT_EQ(initial_size, model_->items().size());
 }