Standardize usage of virtual/override/final in chrome/browser/notifications

chrome/browser/notifications/extension_welcome_notification_unittest.cc

 // Copyright 2014 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/notifications/extension_welcome_notification.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 20 matching lines @@
         notifications_with_shown_as_popup_(0) {
   }
 
   int add_notification_calls() { return add_notification_calls_; }
   int remove_notification_calls() { return remove_notification_calls_; }
   int notifications_with_shown_as_popup() {
     return notifications_with_shown_as_popup_;
   }
 
   // message_center::FakeMessageCenter Overrides
-  virtual message_center::Notification* FindVisibleNotificationById(
+  message_center::Notification* FindVisibleNotificationById(
       const std::string& id) override {
     if (last_notification.get() && last_notification->id() == id)
       return last_notification.get();
     return NULL;
   }
 
-  virtual void AddNotification(
+  void AddNotification(
       scoped_ptr<message_center::Notification> notification) override {
     EXPECT_FALSE(last_notification.get());
     last_notification.swap(notification);
     add_notification_calls_++;
     if (last_notification->shown_as_popup())
       notifications_with_shown_as_popup_++;
   }
 
-  virtual void RemoveNotification(const std::string& id,
-                                  bool by_user) override {
+  void RemoveNotification(const std::string& id, bool by_user) override {
     EXPECT_TRUE(last_notification.get());
     last_notification.reset();
     remove_notification_calls_++;
   }
 
   void CloseCurrentNotification() {
     EXPECT_TRUE(last_notification.get());
     last_notification->delegate()->Close(true);
     RemoveNotification(last_notification->id(), true);
   }
 
  private:
   scoped_ptr<message_center::Notification> last_notification;
   int add_notification_calls_;
   int remove_notification_calls_;
   int notifications_with_shown_as_popup_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMessageCenter);
 };
 
 class WelcomeNotificationDelegate
     : public ExtensionWelcomeNotification::Delegate {
 public:
   WelcomeNotificationDelegate()
       : start_time_(base::Time::Now()),
         message_center_(new MockMessageCenter()) {
   }
 
   // ExtensionWelcomeNotification::Delegate
-  virtual message_center::MessageCenter* GetMessageCenter() override {
+  message_center::MessageCenter* GetMessageCenter() override {
     return message_center_.get();
   }
 
-  virtual base::Time GetCurrentTime() override {
-    return start_time_ + elapsed_time_;
-  }
+  base::Time GetCurrentTime() override { return start_time_ + elapsed_time_; }
 
-  virtual void PostTask(
-      const tracked_objects::Location& from_here,
-      const base::Closure& task) override {
+  void PostTask(const tracked_objects::Location& from_here,
+                const base::Closure& task) override {
     EXPECT_TRUE(pending_task_.is_null());
     pending_task_ = task;
   }
 
   // WelcomeNotificationDelegate
   MockMessageCenter* message_center() const { return message_center_.get(); }
 
   base::Time GetStartTime() const { return start_time_; }
 
   void SetElapsedTime(base::TimeDelta elapsed_time) {
@@ skipping 93 matching lines @@
   void SetInt64Pref(const char* path, int64 value) const {
     profile_->GetPrefs()->SetInt64(path, value);
   }
 
  private:
   class TestNotificationDelegate : public NotificationDelegate {
    public:
     explicit TestNotificationDelegate(const std::string& id) : id_(id) {}
 
     // Overridden from NotificationDelegate:
-    virtual void Display() override {}
-    virtual void Error() override {}
-    virtual void Close(bool by_user) override {}
-    virtual void Click() override {}
-    virtual void ButtonClick(int index) override {}
+    void Display() override {}
+    void Error() override {}
+    void Close(bool by_user) override {}
+    void Click() override {}
+    void ButtonClick(int index) override {}
 
-    virtual std::string id() const override { return id_; }
+    std::string id() const override { return id_; }
 
    private:
-    virtual ~TestNotificationDelegate() {}
+    ~TestNotificationDelegate() override {}
 
     const std::string id_;
 
     DISALLOW_COPY_AND_ASSIGN(TestNotificationDelegate);
   };
 
   void ShowNotification(std::string notification_id,
                         const message_center::NotifierId& notifier_id) const {
     message_center::RichNotificationData rich_notification_data;
     rich_notification_data.priority = 0;
@@ skipping 305 matching lines @@
 
   EXPECT_TRUE(task_runner()->GetPendingTasks().empty());
   EXPECT_EQ(message_center()->add_notification_calls(), 0);
   EXPECT_EQ(message_center()->remove_notification_calls(), 0);
   EXPECT_EQ(message_center()->notifications_with_shown_as_popup(), 0);
   EXPECT_FALSE(GetBooleanPref(prefs::kWelcomeNotificationDismissed));
   EXPECT_TRUE(GetBooleanPref(prefs::kWelcomeNotificationDismissedLocal));
   EXPECT_TRUE(GetBooleanPref(prefs::kWelcomeNotificationPreviouslyPoppedUp));
   EXPECT_EQ(GetInt64Pref(prefs::kWelcomeNotificationExpirationTimestamp), 1);
 }