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

chrome/browser/rlz/rlz_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/rlz/rlz.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/autocomplete/autocomplete_controller.h"
@@ skipping 88 matching lines @@
 
   bool was_ping_sent_for_brand(const std::string& brand) const {
     return pinged_brands_.count(brand) > 0;
   }
 
   void set_assume_not_ui_thread(bool assume_not_ui_thread) {
     assume_not_ui_thread_ = assume_not_ui_thread;
   }
 
  private:
-  virtual void ScheduleDelayedInit(base::TimeDelta delay) OVERRIDE {
+  virtual void ScheduleDelayedInit(base::TimeDelta delay) override {
     // If the delay is 0, invoke the delayed init now. Otherwise,
     // don't schedule anything, it will be manually called during tests.
     if (delay == base::TimeDelta())
       DelayedInit();
   }
 
-  virtual void ScheduleFinancialPing() OVERRIDE {
+  virtual void ScheduleFinancialPing() override {
     PingNowImpl();
   }
 
   virtual bool ScheduleRecordProductEvent(rlz_lib::Product product,
                                           rlz_lib::AccessPoint point,
-                                          rlz_lib::Event event_id) OVERRIDE {
+                                          rlz_lib::Event event_id) override {
     return !assume_not_ui_thread_;
   }
 
-  virtual bool ScheduleGetAccessPointRlz(rlz_lib::AccessPoint point) OVERRIDE {
+  virtual bool ScheduleGetAccessPointRlz(rlz_lib::AccessPoint point) override {
     return !assume_not_ui_thread_;
   }
 
-  virtual bool ScheduleRecordFirstSearch(rlz_lib::AccessPoint point) OVERRIDE {
+  virtual bool ScheduleRecordFirstSearch(rlz_lib::AccessPoint point) override {
     return !assume_not_ui_thread_;
   }
 
 #if defined(OS_CHROMEOS)
-  virtual bool ScheduleClearRlzState() OVERRIDE {
+  virtual bool ScheduleClearRlzState() override {
     return !assume_not_ui_thread_;
   }
 #endif
 
   virtual bool SendFinancialPing(const std::string& brand,
                                  const base::string16& lang,
-                                 const base::string16& referral) OVERRIDE {
+                                 const base::string16& referral) override {
     // Don't ping the server during tests, just pretend as if we did.
     EXPECT_FALSE(brand.empty());
     pinged_brands_.insert(brand);
 
     // Set new access points RLZ string, like the actual server ping would have
     // done.
     rlz_lib::SetAccessPointRlz(RLZTracker::ChromeOmnibox(),
                                kNewOmniboxRlzString);
     rlz_lib::SetAccessPointRlz(RLZTracker::ChromeHomePage(),
                                kNewHomepageRlzString);
     rlz_lib::SetAccessPointRlz(RLZTracker::ChromeAppList(),
                                kNewAppListRlzString);
     return true;
   }
 
   std::set<std::string> pinged_brands_;
   bool assume_not_ui_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRLZTracker);
 };
 
 class RlzLibTest : public RlzLibTestNoMachineState {
  protected:
-  virtual void SetUp() OVERRIDE;
+  virtual void SetUp() override;
 
   void SetMainBrand(const char* brand);
   void SetReactivationBrand(const char* brand);
 #if defined(OS_WIN)
   void SetRegistryBrandValue(const wchar_t* name, const char* brand);
 #endif
 
   void SimulateOmniboxUsage();
   void SimulateHomepageUsage();
   void SimulateAppListUsage();
@@ skipping 710 matching lines @@
   RLZTracker::RecordProductEvent(rlz_lib::CHROME, RLZTracker::ChromeOmnibox(),
                                  rlz_lib::FIRST_SEARCH);
 
   ExpectEventRecorded(kOmniboxFirstSearch, true);
 
   RLZTracker::ClearRlzState();
 
   ExpectEventRecorded(kOmniboxFirstSearch, false);
 }
 #endif  // defined(OS_CHROMEOS)