replace OVERRIDE and FINAL with override and final in chrome/browser/[r-z]*

chrome/browser/sync/test/integration/typed_urls_helper.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/sync/test/integration/typed_urls_helper.h"
 
 #include "base/compiler_specific.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task/cancelable_task_tracker.h"
@@ skipping 10 matching lines @@
 
 using sync_datatype_helper::test;
 
 namespace {
 
 class FlushHistoryDBQueueTask : public history::HistoryDBTask {
  public:
   explicit FlushHistoryDBQueueTask(base::WaitableEvent* event)
       : wait_event_(event) {}
   virtual bool RunOnDBThread(history::HistoryBackend* backend,
-                             history::HistoryDatabase* db) OVERRIDE {
+                             history::HistoryDatabase* db) override {
     wait_event_->Signal();
     return true;
   }
 
-  virtual void DoneRunOnMainThread() OVERRIDE {}
+  virtual void DoneRunOnMainThread() override {}
 
  private:
   virtual ~FlushHistoryDBQueueTask() {}
 
   base::WaitableEvent* wait_event_;
 };
 
 class GetTypedUrlsTask : public history::HistoryDBTask {
  public:
   GetTypedUrlsTask(history::URLRows* rows, base::WaitableEvent* event)
       : rows_(rows), wait_event_(event) {}
 
   virtual bool RunOnDBThread(history::HistoryBackend* backend,
-                             history::HistoryDatabase* db) OVERRIDE {
+                             history::HistoryDatabase* db) override {
     // Fetch the typed URLs.
     backend->GetAllTypedURLs(rows_);
     wait_event_->Signal();
     return true;
   }
 
-  virtual void DoneRunOnMainThread() OVERRIDE {}
+  virtual void DoneRunOnMainThread() override {}
 
  private:
   virtual ~GetTypedUrlsTask() {}
 
   history::URLRows* rows_;
   base::WaitableEvent* wait_event_;
 };
 
 class GetUrlTask : public history::HistoryDBTask {
  public:
   GetUrlTask(const GURL& url,
              history::URLRow* row,
              bool* found,
              base::WaitableEvent* event)
       : url_(url), row_(row), wait_event_(event), found_(found) {}
 
   virtual bool RunOnDBThread(history::HistoryBackend* backend,
-                             history::HistoryDatabase* db) OVERRIDE {
+                             history::HistoryDatabase* db) override {
     // Fetch the typed URLs.
     *found_ = backend->GetURL(url_, row_);
     wait_event_->Signal();
     return true;
   }
 
-  virtual void DoneRunOnMainThread() OVERRIDE {}
+  virtual void DoneRunOnMainThread() override {}
 
  private:
   virtual ~GetUrlTask() {}
 
   GURL url_;
   history::URLRow* row_;
   base::WaitableEvent* wait_event_;
   bool* found_;
 };
 
 class GetVisitsTask : public history::HistoryDBTask {
  public:
   GetVisitsTask(history::URLID id,
                 history::VisitVector* visits,
                 base::WaitableEvent* event)
       : id_(id), visits_(visits), wait_event_(event) {}
 
   virtual bool RunOnDBThread(history::HistoryBackend* backend,
-                             history::HistoryDatabase* db) OVERRIDE {
+                             history::HistoryDatabase* db) override {
     // Fetch the visits.
     backend->GetVisitsForURL(id_, visits_);
     wait_event_->Signal();
     return true;
   }
 
-  virtual void DoneRunOnMainThread() OVERRIDE {}
+  virtual void DoneRunOnMainThread() override {}
 
  private:
   virtual ~GetVisitsTask() {}
 
   history::URLID id_;
   history::VisitVector* visits_;
   base::WaitableEvent* wait_event_;
 };
 
 class RemoveVisitsTask : public history::HistoryDBTask {
  public:
   RemoveVisitsTask(const history::VisitVector& visits,
                    base::WaitableEvent* event)
       : visits_(visits), wait_event_(event) {}
 
   virtual bool RunOnDBThread(history::HistoryBackend* backend,
-                             history::HistoryDatabase* db) OVERRIDE {
+                             history::HistoryDatabase* db) override {
     // Fetch the visits.
     backend->RemoveVisits(visits_);
     wait_event_->Signal();
     return true;
   }
 
-  virtual void DoneRunOnMainThread() OVERRIDE {}
+  virtual void DoneRunOnMainThread() override {}
 
  private:
   virtual ~RemoveVisitsTask() {}
 
   const history::VisitVector& visits_;
   base::WaitableEvent* wait_event_;
 };
 
 // Waits for the history DB thread to finish executing its current set of
 // tasks.
@@ skipping 247 matching lines @@
 
 namespace {
 
 // Helper class used in the implementation of
 // AwaitCheckAllProfilesHaveSameURLsAsVerifier.
 class ProfilesHaveSameURLsChecker : public MultiClientStatusChangeChecker {
  public:
   ProfilesHaveSameURLsChecker();
   virtual ~ProfilesHaveSameURLsChecker();
 
-  virtual bool IsExitConditionSatisfied() OVERRIDE;
-  virtual std::string GetDebugMessage() const OVERRIDE;
+  virtual bool IsExitConditionSatisfied() override;
+  virtual std::string GetDebugMessage() const override;
 };
 
 ProfilesHaveSameURLsChecker::ProfilesHaveSameURLsChecker()
     : MultiClientStatusChangeChecker(
         sync_datatype_helper::test()->GetSyncServices()) {}
 
 ProfilesHaveSameURLsChecker::~ProfilesHaveSameURLsChecker() {}
 
 bool ProfilesHaveSameURLsChecker::IsExitConditionSatisfied() {
   return CheckAllProfilesHaveSameURLsAsVerifier();
 }
 
 std::string ProfilesHaveSameURLsChecker::GetDebugMessage() const {
   return "Waiting for matching typed urls profiles";
 }
 
 }  //  namespace
 
 bool AwaitCheckAllProfilesHaveSameURLsAsVerifier() {
   ProfilesHaveSameURLsChecker checker;
   checker.Wait();
   return !checker.TimedOut();
 }
 
 }  // namespace typed_urls_helper