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

chrome/browser/sync/sessions/session_data_type_controller_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 "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/sync/glue/synced_window_delegate.h"
@@ skipping 12 matching lines @@
 
 namespace {
 
 class MockSyncedWindowDelegate : public SyncedWindowDelegate {
  public:
   explicit MockSyncedWindowDelegate(Profile* profile)
     : is_restore_in_progress_(false),
       profile_(profile) {}
   virtual ~MockSyncedWindowDelegate() {}
 
-  virtual bool HasWindow() const OVERRIDE { return false; }
-  virtual SessionID::id_type GetSessionId() const OVERRIDE { return 0; }
-  virtual int GetTabCount() const OVERRIDE { return 0; }
-  virtual int GetActiveIndex() const OVERRIDE { return 0; }
-  virtual bool IsApp() const OVERRIDE { return false; }
-  virtual bool IsTypeTabbed() const OVERRIDE { return false; }
-  virtual bool IsTypePopup() const OVERRIDE { return false; }
-  virtual bool IsTabPinned(const SyncedTabDelegate* tab) const OVERRIDE {
+  virtual bool HasWindow() const override { return false; }
+  virtual SessionID::id_type GetSessionId() const override { return 0; }
+  virtual int GetTabCount() const override { return 0; }
+  virtual int GetActiveIndex() const override { return 0; }
+  virtual bool IsApp() const override { return false; }
+  virtual bool IsTypeTabbed() const override { return false; }
+  virtual bool IsTypePopup() const override { return false; }
+  virtual bool IsTabPinned(const SyncedTabDelegate* tab) const override {
     return false;
   }
-  virtual SyncedTabDelegate* GetTabAt(int index) const OVERRIDE { return NULL; }
-  virtual SessionID::id_type GetTabIdAt(int index) const OVERRIDE { return 0; }
+  virtual SyncedTabDelegate* GetTabAt(int index) const override { return NULL; }
+  virtual SessionID::id_type GetTabIdAt(int index) const override { return 0; }
 
-  virtual bool IsSessionRestoreInProgress() const OVERRIDE {
+  virtual bool IsSessionRestoreInProgress() const override {
     return is_restore_in_progress_;
   }
 
   void SetSessionRestoreInProgress(bool is_restore_in_progress) {
     is_restore_in_progress_ = is_restore_in_progress;
 
     if (!is_restore_in_progress_) {
       content::NotificationService::current()->Notify(
           chrome::NOTIFICATION_SESSION_RESTORE_COMPLETE,
           content::Source<Profile>(profile_),
           content::NotificationService::NoDetails());
     }
   }
 
  private:
   bool is_restore_in_progress_;
   Profile* profile_;
 };
 
 class MockSyncedWindowDelegatesGetter : public SyncedWindowDelegatesGetter {
  public:
   virtual const std::set<SyncedWindowDelegate*>
-  GetSyncedWindowDelegates() OVERRIDE {
+  GetSyncedWindowDelegates() override {
     return delegates_;
   }
 
   void Add(SyncedWindowDelegate* delegate) {
     delegates_.insert(delegate);
   }
 
  private:
   std::set<SyncedWindowDelegate*> delegates_;
 };
 
 class SessionDataTypeControllerTest
     : public testing::Test {
  public:
   SessionDataTypeControllerTest()
       : load_finished_(false),
         thread_bundle_(content::TestBrowserThreadBundle::DEFAULT),
         weak_ptr_factory_(this),
         last_type_(syncer::UNSPECIFIED) {}
   virtual ~SessionDataTypeControllerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     synced_window_delegate_.reset(new MockSyncedWindowDelegate(&profile_));
     synced_window_getter_.reset(new MockSyncedWindowDelegatesGetter());
     synced_window_getter_->Add(synced_window_delegate_.get());
 
     local_device_.reset(new LocalDeviceInfoProviderMock(
         "cache_guid",
         "Wayne Gretzky's Hacking Box",
         "Chromium 10k",
         "Chrome 10k",
         sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
         "device_id"));
 
     controller_ = new SessionDataTypeController(
         &profile_sync_factory_,
         &profile_,
         synced_window_getter_.get(),
         local_device_.get());
 
     load_finished_ = false;
     last_type_ = syncer::UNSPECIFIED;
     last_error_ = syncer::SyncError();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     controller_ = NULL;
     local_device_.reset();
     synced_window_getter_.reset();
     synced_window_delegate_.reset();
   }
 
   void Start() {
     controller_->LoadModels(
       base::Bind(&SessionDataTypeControllerTest::OnLoadFinished,
                  weak_ptr_factory_.GetWeakPtr()));
@@ skipping 111 matching lines @@
 
   local_device_->SetInitialized(true);
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
             controller_->state());
   EXPECT_TRUE(LoadResult());
 }
 
 }  // namespace
 
 }  // namespace browser_sync