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

chrome/browser/notifications/extension_welcome_notification.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 "base/guid.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
@@ skipping 29 matching lines @@
       const message_center::NotifierId notifier_id,
       const std::string& welcome_notification_id,
       ExtensionWelcomeNotification::Delegate* delegate)
       : profile_(profile),
         notifier_id_(notifier_id.type, notifier_id.id),
         welcome_notification_id_(welcome_notification_id),
         delegate_(delegate) {
   }
 
   // Overridden from NotificationDelegate:
-  virtual void Display() override {}
-  virtual void Error() override {}
+  void Display() override {}
+  void Error() override {}
 
-  virtual void Close(bool by_user) override {
+  void Close(bool by_user) override {
     if (by_user) {
       // Setting the preference here may cause the notification erasing
       // to reenter. Posting a task avoids this issue.
       delegate_->PostTask(
           FROM_HERE,
           base::Bind(&NotificationCallbacks::MarkAsDismissed, this));
     }
   }
 
-  virtual void Click() override {}
-  virtual void ButtonClick(int index) override {
+  void Click() override {}
+  void ButtonClick(int index) override {
     if (index == 0) {
       OpenNotificationLearnMoreTab();
     } else if (index == 1) {
       DisableNotificationProvider();
       Close(true);
     } else {
       NOTREACHED();
     }
   }
 
@@ skipping 16 matching lines @@
   void DisableNotificationProvider() {
     message_center::Notifier notifier(notifier_id_, base::string16(), true);
     message_center::MessageCenter* message_center =
         delegate_->GetMessageCenter();
     message_center->DisableNotificationsByNotifier(notifier_id_);
     message_center->RemoveNotification(welcome_notification_id_, false);
     message_center->GetNotifierSettingsProvider()->SetNotifierEnabled(
         notifier, false);
   }
 
-  virtual ~NotificationCallbacks() {}
+  ~NotificationCallbacks() override {}
 
   Profile* const profile_;
 
   const message_center::NotifierId notifier_id_;
 
   std::string welcome_notification_id_;
 
   // Weak ref owned by ExtensionWelcomeNotification.
   ExtensionWelcomeNotification::Delegate* const delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationCallbacks);
 };
 
 class DefaultDelegate : public ExtensionWelcomeNotification::Delegate {
  public:
   DefaultDelegate() {}
 
-  virtual message_center::MessageCenter* GetMessageCenter() override {
+  message_center::MessageCenter* GetMessageCenter() override {
     return g_browser_process->message_center();
   }
 
-  virtual base::Time GetCurrentTime() override {
-    return base::Time::Now();
-  }
+  base::Time GetCurrentTime() override { return base::Time::Now(); }
 
-  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 {
     base::MessageLoop::current()->PostTask(from_here, task);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultDelegate);
 };
 
 }  // namespace
 
 ExtensionWelcomeNotification::ExtensionWelcomeNotification(
@@ skipping 218 matching lines @@
       prefs::kWelcomeNotificationExpirationTimestamp,
       (delegate_->GetCurrentTime() +
           base::TimeDelta::FromDays(kRequestedShowTimeDays)).ToInternalValue());
 }
 
 bool ExtensionWelcomeNotification::IsWelcomeNotificationExpired() const {
   const base::Time expiration_timestamp = GetExpirationTimestamp();
   return !expiration_timestamp.is_null() &&
          (expiration_timestamp <= delegate_->GetCurrentTime());
 }