Standardize usage of virtual/override/final specifiers.

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 76 matching lines @@
 
 // ShelfModelObserver implementation that tracks what messages are invoked.
 class TestShelfModelObserver : public ash::ShelfModelObserver {
  public:
   TestShelfModelObserver()
     : added_(0),
       removed_(0),
       changed_(0) {
   }
 
-  virtual ~TestShelfModelObserver() {
-  }
+  ~TestShelfModelObserver() override {}
 
   // Overridden from ash::ShelfModelObserver:
-  virtual void ShelfItemAdded(int index) override {
+  void ShelfItemAdded(int index) override {
     ++added_;
     last_index_ = index;
   }
 
-  virtual void ShelfItemRemoved(int index, ash::ShelfID id) override {
+  void ShelfItemRemoved(int index, ash::ShelfID id) override {
     ++removed_;
     last_index_ = index;
   }
 
-  virtual void ShelfItemChanged(int index,
-                                const ash::ShelfItem& old_item) override {
+  void ShelfItemChanged(int index, const ash::ShelfItem& old_item) override {
     ++changed_;
     last_index_ = index;
   }
 
-  virtual void ShelfItemMoved(int start_index, int target_index) override {
+  void ShelfItemMoved(int start_index, int target_index) override {
     last_index_ = target_index;
   }
 
-  virtual void ShelfStatusChanged() override {
-  }
+  void ShelfStatusChanged() override {}
 
   void clear_counts() {
     added_ = 0;
     removed_ = 0;
     changed_ = 0;
     last_index_ = 0;
   }
 
   int added() const { return added_; }
   int removed() const { return removed_; }
   int changed() const { return changed_; }
   int last_index() const { return last_index_; }
 
  private:
   int added_;
   int removed_;
   int changed_;
   int last_index_;
 
   DISALLOW_COPY_AND_ASSIGN(TestShelfModelObserver);
 };
 
 // Test implementation of AppIconLoader.
 class TestAppIconLoaderImpl : public extensions::AppIconLoader {
  public:
   TestAppIconLoaderImpl() : fetch_count_(0) {
   }
 
-  virtual ~TestAppIconLoaderImpl() {
-  }
+  ~TestAppIconLoaderImpl() override {}
 
   // AppIconLoader implementation:
-  virtual void FetchImage(const std::string& id) override {
-    ++fetch_count_;
-  }
+  void FetchImage(const std::string& id) override { ++fetch_count_; }
 
-  virtual void ClearImage(const std::string& id) override {
-  }
+  void ClearImage(const std::string& id) override {}
 
-  virtual void UpdateImage(const std::string& id) override {
-  }
+  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() {}
+  ~TestAppTabHelperImpl() override {}
 
   // 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 {
+  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 {
+  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 {
+  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() {}
+  ~TestV2AppLauncherItemController() override {}
 
   // 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 ChromeLauncherAppMenuItems GetApplicationList(
-      int event_flags) override {
+  bool IsOpen() const override { return true; }
+  bool IsVisible() const override { return true; }
+  void Launch(ash::LaunchSource source, int event_flags) override {}
+  bool Activate(ash::LaunchSource source) override { return false; }
+  void Close() override {}
+  bool ItemSelected(const ui::Event& event) override { return false; }
+  base::string16 GetTitle() override { return base::string16(); }
+  ChromeLauncherAppMenuItems GetApplicationList(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 {
+  ui::MenuModel* CreateContextMenu(aura::Window* root_window) override {
     return NULL;
   }
-  virtual ash::ShelfMenuModel* CreateApplicationMenu(int event_flags) override {
+  ash::ShelfMenuModel* CreateApplicationMenu(int event_flags) override {
     return NULL;
   }
-  virtual bool IsDraggable() override { return false; }
-  virtual bool ShouldShowTooltip() override { return false; }
+  bool IsDraggable() override { return false; }
+  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() {
-  }
+  ~ChromeLauncherControllerTest() override {}
 
-  virtual void SetUp() override {
+  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 {
+  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 2261 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());
 }