replace OVERRIDE and FINAL with override and final in chrome/browser/ui/[t-v]*

chrome/browser/ui/tabs/tab_strip_model_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 "chrome/browser/ui/tabs/tab_strip_model.h"
 
 #include <map>
 #include <string>
 
 #include "base/files/file_path.h"
@@ skipping 41 matching lines @@
   // When |source| is deleted both |tab_to_delete| and |tab_strip| are deleted.
   // |tab_to_delete| and |tab_strip| may be NULL.
   DeleteWebContentsOnDestroyedObserver(WebContents* source,
                                        WebContents* tab_to_delete,
                                        TabStripModel* tab_strip)
       : WebContentsObserver(source),
         tab_to_delete_(tab_to_delete),
         tab_strip_(tab_strip) {
   }
 
-  virtual void WebContentsDestroyed() OVERRIDE {
+  virtual void WebContentsDestroyed() override {
     WebContents* tab_to_delete = tab_to_delete_;
     tab_to_delete_ = NULL;
     TabStripModel* tab_strip_to_delete = tab_strip_;
     tab_strip_ = NULL;
     delete tab_to_delete;
     delete tab_strip_to_delete;
   }
 
  private:
   WebContents* tab_to_delete_;
   TabStripModel* tab_strip_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteWebContentsOnDestroyedObserver);
 };
 
 class TabStripDummyDelegate : public TestTabStripModelDelegate {
  public:
   TabStripDummyDelegate() : run_unload_(false) {}
   virtual ~TabStripDummyDelegate() {}
 
   void set_run_unload_listener(bool value) { run_unload_ = value; }
 
-  virtual bool RunUnloadListenerBeforeClosing(WebContents* contents) OVERRIDE {
+  virtual bool RunUnloadListenerBeforeClosing(WebContents* contents) override {
     return run_unload_;
   }
 
  private:
   // Whether to report that we need to run an unload listener before closing.
   bool run_unload_;
 
   DISALLOW_COPY_AND_ASSIGN(TabStripDummyDelegate);
 };
 
@@ skipping 12 matching lines @@
 class DummySingleWebContentsDialogManager
     : public web_modal::SingleWebContentsDialogManager {
  public:
   explicit DummySingleWebContentsDialogManager(
       NativeWebContentsModalDialog dialog,
       web_modal::SingleWebContentsDialogManagerDelegate* delegate)
       : delegate_(delegate),
         dialog_(dialog) {}
   virtual ~DummySingleWebContentsDialogManager() {}
 
-  virtual void Show() OVERRIDE {}
-  virtual void Hide() OVERRIDE {}
-  virtual void Close() OVERRIDE {
+  virtual void Show() override {}
+  virtual void Hide() override {}
+  virtual void Close() override {
     delegate_->WillClose(dialog_);
   }
-  virtual void Focus() OVERRIDE {}
-  virtual void Pulse() OVERRIDE {}
+  virtual void Focus() override {}
+  virtual void Pulse() override {}
   virtual void HostChanged(
-      web_modal::WebContentsModalDialogHost* new_host) OVERRIDE {}
-  virtual NativeWebContentsModalDialog dialog() OVERRIDE { return dialog_; }
+      web_modal::WebContentsModalDialogHost* new_host) override {}
+  virtual NativeWebContentsModalDialog dialog() override { return dialog_; }
 
  private:
   web_modal::SingleWebContentsDialogManagerDelegate* delegate_;
   NativeWebContentsModalDialog dialog_;
 
   DISALLOW_COPY_AND_ASSIGN(DummySingleWebContentsDialogManager);
 };
 
 // Test Browser-like class for TabStripModelTest.TabBlockedState.
 class TabBlockedStateTestBrowser
     : public TabStripModelObserver,
       public web_modal::WebContentsModalDialogManagerDelegate {
  public:
   explicit TabBlockedStateTestBrowser(TabStripModel* tab_strip_model)
       : tab_strip_model_(tab_strip_model) {
     tab_strip_model_->AddObserver(this);
   }
 
   virtual ~TabBlockedStateTestBrowser() {
     tab_strip_model_->RemoveObserver(this);
   }
 
  private:
   // TabStripModelObserver
   virtual void TabInsertedAt(WebContents* contents,
                              int index,
-                             bool foreground) OVERRIDE {
+                             bool foreground) override {
     web_modal::WebContentsModalDialogManager* manager =
         web_modal::WebContentsModalDialogManager::FromWebContents(contents);
     if (manager)
       manager->SetDelegate(this);
   }
 
   // WebContentsModalDialogManagerDelegate
   virtual void SetWebContentsBlocked(content::WebContents* contents,
-                                     bool blocked) OVERRIDE {
+                                     bool blocked) override {
     int index = tab_strip_model_->GetIndexOfWebContents(contents);
     ASSERT_GE(index, 0);
     tab_strip_model_->SetTabBlocked(index, blocked);
   }
 
   TabStripModel* tab_strip_model_;
 
   DISALLOW_COPY_AND_ASSIGN(TabBlockedStateTestBrowser);
 };
 
@@ skipping 169 matching lines @@
             s.src_index == state.src_index &&
             s.dst_index == state.dst_index &&
             s.change_reason == state.change_reason &&
             s.foreground == state.foreground &&
             s.action == state.action);
   }
 
   // TabStripModelObserver implementation:
   virtual void TabInsertedAt(WebContents* contents,
                              int index,
-                             bool foreground) OVERRIDE {
+                             bool foreground) override {
     empty_ = false;
     State s(contents, index, INSERT);
     s.foreground = foreground;
     states_.push_back(s);
   }
   virtual void ActiveTabChanged(WebContents* old_contents,
                                 WebContents* new_contents,
                                 int index,
-                                int reason) OVERRIDE {
+                                int reason) override {
     State s(new_contents, index, ACTIVATE);
     s.src_contents = old_contents;
     s.change_reason = reason;
     states_.push_back(s);
   }
   virtual void TabSelectionChanged(
       TabStripModel* tab_strip_model,
-      const ui::ListSelectionModel& old_model) OVERRIDE {
+      const ui::ListSelectionModel& old_model) override {
     State s(model()->GetActiveWebContents(), model()->active_index(), SELECT);
     s.src_contents = model()->GetWebContentsAt(old_model.active());
     s.src_index = old_model.active();
     states_.push_back(s);
   }
   virtual void TabMoved(WebContents* contents,
                         int from_index,
-                        int to_index) OVERRIDE {
+                        int to_index) override {
     State s(contents, to_index, MOVE);
     s.src_index = from_index;
     states_.push_back(s);
   }
 
   virtual void TabClosingAt(TabStripModel* tab_strip_model,
                             WebContents* contents,
-                            int index) OVERRIDE {
+                            int index) override {
     states_.push_back(State(contents, index, CLOSE));
   }
-  virtual void TabDetachedAt(WebContents* contents, int index) OVERRIDE {
+  virtual void TabDetachedAt(WebContents* contents, int index) override {
     states_.push_back(State(contents, index, DETACH));
   }
-  virtual void TabDeactivated(WebContents* contents) OVERRIDE {
+  virtual void TabDeactivated(WebContents* contents) override {
     states_.push_back(State(contents, model()->active_index(), DEACTIVATE));
   }
   virtual void TabChangedAt(WebContents* contents,
                             int index,
-                            TabChangeType change_type) OVERRIDE {
+                            TabChangeType change_type) override {
     states_.push_back(State(contents, index, CHANGE));
   }
   virtual void TabReplacedAt(TabStripModel* tab_strip_model,
                              WebContents* old_contents,
                              WebContents* new_contents,
-                             int index) OVERRIDE {
+                             int index) override {
     State s(new_contents, index, REPLACED);
     s.src_contents = old_contents;
     states_.push_back(s);
   }
   virtual void TabPinnedStateChanged(WebContents* contents,
-                                     int index) OVERRIDE {
+                                     int index) override {
     states_.push_back(State(contents, index, PINNED));
   }
-  virtual void TabStripEmpty() OVERRIDE {
+  virtual void TabStripEmpty() override {
     empty_ = true;
   }
-  virtual void WillCloseAllTabs() OVERRIDE {
+  virtual void WillCloseAllTabs() override {
     states_.push_back(State(NULL, -1, CLOSE_ALL));
   }
-  virtual void CloseAllTabsCanceled() OVERRIDE {
+  virtual void CloseAllTabsCanceled() override {
     states_.push_back(State(NULL, -1, CLOSE_ALL_CANCELED));
   }
-  virtual void TabStripModelDeleted() OVERRIDE {
+  virtual void TabStripModelDeleted() override {
     deleted_ = true;
   }
 
   void ClearStates() {
     states_.clear();
   }
 
   bool empty() const { return empty_; }
   bool deleted() const { return deleted_; }
   TabStripModel* model() { return model_; }
@@ skipping 2152 matching lines @@
   WebContents* moved_contents = strip_src.DetachWebContentsAt(1);
   EXPECT_EQ(contents2, moved_contents);
 
   // Attach the tab to the destination tab strip.
   strip_dst.AppendWebContents(moved_contents, true);
   EXPECT_TRUE(strip_dst.IsTabBlocked(0));
 
   strip_dst.CloseAllTabs();
   strip_src.CloseAllTabs();
 }