Standardize usage of virtual/override/final specifiers.

ash/shelf/shelf_view_unittest.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 "ash/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/root_window_controller.h"
@@ skipping 45 matching lines @@
 
 class TestShelfIconObserver : public ShelfIconObserver {
  public:
   explicit TestShelfIconObserver(Shelf* shelf)
       : shelf_(shelf),
         change_notified_(false) {
     if (shelf_)
       shelf_->AddIconObserver(this);
   }
 
-  virtual ~TestShelfIconObserver() {
+  ~TestShelfIconObserver() override {
     if (shelf_)
       shelf_->RemoveIconObserver(this);
   }
 
   // ShelfIconObserver implementation.
-  virtual void OnShelfIconPositionsChanged() override {
-    change_notified_ = true;
-  }
+  void OnShelfIconPositionsChanged() override { change_notified_ = true; }
 
   int change_notified() const { return change_notified_; }
   void Reset() { change_notified_ = false; }
 
  private:
   Shelf* shelf_;
   bool change_notified_;
 
   DISALLOW_COPY_AND_ASSIGN(TestShelfIconObserver);
 };
 
 class ShelfViewIconObserverTest : public AshTestBase {
  public:
   ShelfViewIconObserverTest() {}
-  virtual ~ShelfViewIconObserverTest() {}
+  ~ShelfViewIconObserverTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AshTestBase::SetUp();
     Shelf* shelf = Shelf::ForPrimaryDisplay();
     observer_.reset(new TestShelfIconObserver(shelf));
 
     shelf_view_test_.reset(
         new ShelfViewTestAPI(ShelfTestAPI(shelf).shelf_view()));
     shelf_view_test_->SetAnimationDuration(1);
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     observer_.reset();
     AshTestBase::TearDown();
   }
 
   TestShelfIconObserver* observer() { return observer_.get(); }
 
   ShelfViewTestAPI* shelf_view_test() {
     return shelf_view_test_.get();
   }
 
   Shelf* ShelfForSecondaryDisplay() {
     return Shelf::ForWindow(Shell::GetAllRootWindows()[1]);
   }
 
  private:
   scoped_ptr<TestShelfIconObserver> observer_;
   scoped_ptr<ShelfViewTestAPI> shelf_view_test_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfViewIconObserverTest);
 };
 
 // TestShelfItemDelegate which tracks whether it gets selected.
 class ShelfItemSelectionTracker : public TestShelfItemDelegate {
  public:
   ShelfItemSelectionTracker() : TestShelfItemDelegate(NULL), selected_(false) {
   }
 
-  virtual ~ShelfItemSelectionTracker() {
-  }
+  ~ShelfItemSelectionTracker() override {}
 
   // Resets to the initial state.
   void Reset() { selected_ = false; }
 
   // Returns true if the delegate was selected.
   bool WasSelected() {
     return selected_;
   }
 
   // TestShelfItemDelegate:
-  virtual bool ItemSelected(const ui::Event& event) override {
+  bool ItemSelected(const ui::Event& event) override {
     selected_ = true;
     return false;
   }
 
  private:
   bool selected_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfItemSelectionTracker);
 };
 
@@ skipping 74 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfView tests.
 
 // Simple ShelfDelegate implmentation for ShelfViewTest.OverflowBubbleSize
 // and CheckDragAndDropFromOverflowBubbleToShelf
 class TestShelfDelegateForShelfView : public ShelfDelegate {
  public:
   explicit TestShelfDelegateForShelfView(ShelfModel* model)
       : model_(model) {}
-  virtual ~TestShelfDelegateForShelfView() {}
+  ~TestShelfDelegateForShelfView() override {}
 
   // ShelfDelegate overrides:
-  virtual void OnShelfCreated(Shelf* shelf) override {}
+  void OnShelfCreated(Shelf* shelf) override {}
 
-  virtual void OnShelfDestroyed(Shelf* shelf) override {}
+  void OnShelfDestroyed(Shelf* shelf) override {}
 
-  virtual ShelfID GetShelfIDForAppID(const std::string& app_id) override {
+  ShelfID GetShelfIDForAppID(const std::string& app_id) override {
     ShelfID id = 0;
     EXPECT_TRUE(base::StringToInt(app_id, &id));
     return id;
   }
 
-  virtual const std::string& GetAppIDForShelfID(ShelfID id) override {
+  const std::string& GetAppIDForShelfID(ShelfID id) override {
     // Use |app_id_| member variable because returning a reference to local
     // variable is not allowed.
     app_id_ = base::IntToString(id);
     return app_id_;
   }
 
-  virtual void PinAppWithID(const std::string& app_id) override {
-  }
+  void PinAppWithID(const std::string& app_id) override {}
 
-  virtual bool IsAppPinned(const std::string& app_id) override {
+  bool IsAppPinned(const std::string& app_id) override {
     // Returns true for ShelfViewTest.OverflowBubbleSize. To test ripping off in
     // that test, an item is already pinned state.
     return true;
   }
 
-  virtual bool CanPin() const override {
-    return true;
-  }
+  bool CanPin() const override { return true; }
 
-  virtual void UnpinAppWithID(const std::string& app_id) override {
+  void UnpinAppWithID(const std::string& app_id) override {
     ShelfID id = 0;
     EXPECT_TRUE(base::StringToInt(app_id, &id));
     ASSERT_GT(id, 0);
     int index = model_->ItemIndexByID(id);
     ASSERT_GE(index, 0);
 
     model_->RemoveItemAt(index);
   }
 
  private:
   ShelfModel* model_;
 
   // Temp member variable for returning a value. See the comment in the
   // GetAppIDForShelfID().
   std::string app_id_;
 
   DISALLOW_COPY_AND_ASSIGN(TestShelfDelegateForShelfView);
 };
 
 class ShelfViewTest : public AshTestBase {
  public:
   ShelfViewTest()
       : model_(NULL),
         shelf_view_(NULL),
         browser_index_(1),
         item_manager_(NULL) {}
-  virtual ~ShelfViewTest() {}
+  ~ShelfViewTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kEnableTouchFeedback);
     AshTestBase::SetUp();
     test::ShellTestApi test_api(Shell::GetInstance());
     model_ = test_api.shelf_model();
     Shelf* shelf = Shelf::ForPrimaryDisplay();
     shelf_view_ = ShelfTestAPI(shelf).shelf_view();
 
     // The bounds should be big enough for 4 buttons + overflow chevron.
     shelf_view_->SetBounds(0, 0, 500, kShelfSize);
 
     test_api_.reset(new ShelfViewTestAPI(shelf_view_));
     test_api_->SetAnimationDuration(1);  // Speeds up animation for test.
 
     item_manager_ = Shell::GetInstance()->shelf_item_delegate_manager();
     DCHECK(item_manager_);
 
     // Add browser shortcut shelf item at index 0 for test.
     AddBrowserShortcut();
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     test_api_.reset();
     AshTestBase::TearDown();
   }
 
  protected:
   void CreateAndSetShelfItemDelegateForID(ShelfID id) {
     scoped_ptr<ShelfItemDelegate> delegate(new TestShelfItemDelegate(NULL));
     item_manager_->SetShelfItemDelegate(id, delegate.Pass());
   }
 
@@ skipping 325 matching lines @@
   std::string original_locale_;
 };
 
 class ShelfViewTextDirectionTest
     : public ShelfViewTest,
       public testing::WithParamInterface<bool> {
  public:
   ShelfViewTextDirectionTest() : text_direction_change_(GetParam()) {}
   virtual ~ShelfViewTextDirectionTest() {}
 
-  virtual void SetUp() override {
-    ShelfViewTest::SetUp();
-  }
+  void SetUp() override { ShelfViewTest::SetUp(); }
 
-  virtual void TearDown() override {
-    ShelfViewTest::TearDown();
-  }
+  void TearDown() override { ShelfViewTest::TearDown(); }
 
  private:
   ScopedTextDirectionChange text_direction_change_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfViewTextDirectionTest);
 };
 
 // Checks that the ideal item icon bounds match the view's bounds in the screen
 // in both LTR and RTL.
 TEST_P(ShelfViewTextDirectionTest, IdealBoundsOfItemIcon) {
@@ skipping 1080 matching lines @@
   test_api_->RunMessageLoopUntilAnimationsDone();
   CheckAllItemsAreInBounds();
 }
 
 INSTANTIATE_TEST_CASE_P(LtrRtl, ShelfViewTextDirectionTest, testing::Bool());
 INSTANTIATE_TEST_CASE_P(VisibleBounds, ShelfViewVisibleBoundsTest,
     testing::Bool());
 
 }  // namespace test
 }  // namespace ash