replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

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 21 matching lines @@
   }
 
   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(
-      const std::string& id) OVERRIDE {
+      const std::string& id) override {
     if (last_notification.get() && last_notification->id() == id)
       return last_notification.get();
     return NULL;
   }
 
   virtual void AddNotification(
-      scoped_ptr<message_center::Notification> notification) OVERRIDE {
+      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 {
+                                  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 {
+  virtual message_center::MessageCenter* GetMessageCenter() override {
     return message_center_.get();
   }
 
-  virtual base::Time GetCurrentTime() OVERRIDE {
+  virtual base::Time GetCurrentTime() override {
     return start_time_ + elapsed_time_;
   }
 
   virtual void PostTask(
       const tracked_objects::Location& from_here,
-      const base::Closure& task) OVERRIDE {
+      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 {}
+    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 {}
 
-    virtual std::string id() const OVERRIDE { return id_; }
+    virtual std::string id() const override { return id_; }
 
-    virtual content::WebContents* GetWebContents() const OVERRIDE {
+    virtual content::WebContents* GetWebContents() const override {
       return NULL;
     }
 
    private:
     virtual ~TestNotificationDelegate() {}
 
     const std::string id_;
 
     DISALLOW_COPY_AND_ASSIGN(TestNotificationDelegate);
   };
@@ skipping 310 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);
 }