replace OVERRIDE and FINAL with override and final in sync/

sync/internal_api/public/base/cancelation_signal_unittest.cc

 // Copyright 2013 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 "sync/internal_api/public/base/cancelation_signal.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
@@ skipping 15 matching lines @@
 
   // Blocks until canceled.  Signals |task_done_signal| when finished (either
   // via early cancel or cancel after start).  Signals |task_start_signal| if
   // and when the task starts successfully (which will not happen if the task
   // was cancelled early).
   void Run(base::WaitableEvent* task_start_signal,
            base::WaitableEvent* task_done_signal);
 
   // Implementation of CancelationObserver.
   // Wakes up the thread blocked in Run().
-  virtual void OnSignalReceived() OVERRIDE;
+  virtual void OnSignalReceived() override;
 
   // Checks if we ever did successfully start waiting for |event_|.  Be careful
   // with this.  The flag itself is thread-unsafe, and the event that flips it
   // is racy.
   bool WasStarted();
 
  private:
   base::WaitableEvent event_;
   base::Thread exec_thread_;
   CancelationSignal* cancel_signal_;
@@ skipping 96 matching lines @@
 
 bool CancelationSignalTest::VerifyTaskNotStarted() {
   // Wait until BlockingTask::Run() has finished.
   task_done_event_.Wait();
 
   // Verify the background thread never started blocking.
   return !blocking_task_.WasStarted();
 }
 
 class FakeCancelationObserver : public CancelationObserver {
-  virtual void OnSignalReceived() OVERRIDE { }
+  virtual void OnSignalReceived() override { }
 };
 
 TEST(CancelationSignalTest_SingleThread, CheckFlags) {
   FakeCancelationObserver observer;
   CancelationSignal signal;
 
   EXPECT_FALSE(signal.IsSignalled());
   signal.Signal();
   EXPECT_TRUE(signal.IsSignalled());
   EXPECT_FALSE(signal.TryRegisterHandler(&observer));
@@ skipping 13 matching lines @@
 // progress.
 TEST_F(CancelationSignalTest, Cancel) {
   StartBlockingTaskAndWaitForItToStart();
 
   // Wait for the task to finish and let verify it has been started.
   CancelBlocking();
   EXPECT_FALSE(VerifyTaskNotStarted());
 }
 
 }  // namespace syncer