replace OVERRIDE and FINAL with override and final in cc/

cc/scheduler/begin_frame_source_unittest.cc

 // Copyright 2011 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 <deque>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 238 matching lines @@
   source.SetNeedsBeginFrames(true);
   EXPECT_TRUE(source.NeedsBeginFrames());
   source.SetNeedsBeginFrames(false);
   EXPECT_FALSE(source.NeedsBeginFrames());
 }
 
 class LoopingBeginFrameObserver : public BeginFrameObserverMixIn {
  public:
   BeginFrameSource* source_;
 
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE {
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override {
     dict->SetString("type", "LoopingBeginFrameObserver");
     dict->BeginDictionary("source");
     source_->AsValueInto(dict);
     dict->EndDictionary();
   }
 
  protected:
   // BeginFrameObserverMixIn
-  virtual bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) OVERRIDE {
+  virtual bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) override {
     return true;
   }
 };
 
 TEST(BeginFrameSourceMixInTest, DetectAsValueIntoLoop) {
   LoopingBeginFrameObserver obs;
   FakeBeginFrameSource source;
 
   obs.source_ = &source;
   source.AddObserver(&obs);
@@ skipping 11 matching lines @@
       base::SingleThreadTaskRunner* task_runner) {
     return make_scoped_ptr(
         new TestBackToBackBeginFrameSource(now_src, task_runner));
   }
 
  protected:
   TestBackToBackBeginFrameSource(scoped_refptr<TestNowSource> now_src,
                                  base::SingleThreadTaskRunner* task_runner)
       : BackToBackBeginFrameSource(task_runner), now_src_(now_src) {}
 
-  virtual base::TimeTicks Now() OVERRIDE { return now_src_->Now(); }
+  virtual base::TimeTicks Now() override { return now_src_->Now(); }
 
   scoped_refptr<TestNowSource> now_src_;
 };
 
 class BackToBackBeginFrameSourceTest : public ::testing::Test {
  public:
   static const int64_t kDeadline;
   static const int64_t kInterval;
 
   scoped_refptr<TestNowSource> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   scoped_ptr<TestBackToBackBeginFrameSource> source_;
   scoped_ptr<MockBeginFrameObserver> obs_;
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     now_src_ = TestNowSource::Create(1000);
     task_runner_ =
         make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_, false));
     task_runner_->SetRunTaskLimit(1);
     source_ =
         TestBackToBackBeginFrameSource::Create(now_src_, task_runner_.get());
     obs_ = make_scoped_ptr(new ::testing::StrictMock<MockBeginFrameObserver>());
     source_->AddObserver(obs_.get());
   }
 
-  virtual void TearDown() OVERRIDE { obs_.reset(); }
+  virtual void TearDown() override { obs_.reset(); }
 };
 
 const int64_t BackToBackBeginFrameSourceTest::kDeadline =
     BeginFrameArgs::DefaultInterval().ToInternalValue();
 
 const int64_t BackToBackBeginFrameSourceTest::kInterval =
     BeginFrameArgs::DefaultInterval().ToInternalValue();
 
 TEST_F(BackToBackBeginFrameSourceTest, SetNeedsBeginFramesSendsBeginFrame) {
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
@@ skipping 134 matching lines @@
 }
 
 // SyntheticBeginFrameSource testing ------------------------------------------
 class SyntheticBeginFrameSourceTest : public ::testing::Test {
  public:
   scoped_refptr<TestNowSource> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   scoped_ptr<TestSyntheticBeginFrameSource> source_;
   scoped_ptr<MockBeginFrameObserver> obs_;
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     now_src_ = TestNowSource::Create(1000);
     task_runner_ =
         make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_, false));
     source_ = TestSyntheticBeginFrameSource::Create(
         now_src_, task_runner_.get(), base::TimeDelta::FromMicroseconds(10000));
     obs_ = make_scoped_ptr(new MockBeginFrameObserver());
     source_->AddObserver(obs_.get());
   }
 
-  virtual void TearDown() OVERRIDE { obs_.reset(); }
+  virtual void TearDown() override { obs_.reset(); }
 };
 
 TEST_F(SyntheticBeginFrameSourceTest,
        SetNeedsBeginFramesCallsOnBeginFrameWithMissedTick) {
   now_src_->SetNowMicroseconds(10010);
   EXPECT_CALL((*obs_),
               OnBeginFrame(CreateTypedBeginFrameArgsForTesting(
                   10000, 20000, 10000, BeginFrameArgs::MISSED)));
   source_->SetNeedsBeginFrames(true);  // Should cause the last tick to be sent
   // No tasks should need to be run for this to occur.
@@ skipping 38 matching lines @@
 
   EXPECT_BEGIN_FRAME_USED(*obs_, 40000, 47502, 10001);
   EXPECT_BEGIN_FRAME_USED(*obs_, 47502, 57503, 10001);
   EXPECT_BEGIN_FRAME_USED(*obs_, 57503, 67504, 10001);
   task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60000));
 }
 
 // BeginFrameSourceMultiplexer testing -----------------------------------
 class BeginFrameSourceMultiplexerTest : public ::testing::Test {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     mux_ = BeginFrameSourceMultiplexer::Create();
 
     source1_store_ = make_scoped_ptr(new FakeBeginFrameSource());
     source2_store_ = make_scoped_ptr(new FakeBeginFrameSource());
     source3_store_ = make_scoped_ptr(new FakeBeginFrameSource());
 
     source1_ = source1_store_.get();
     source2_ = source2_store_.get();
     source3_ = source3_store_.get();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Make sure the mux is torn down before the sources.
     mux_.reset();
   }
 
   scoped_ptr<BeginFrameSourceMultiplexer> mux_;
   FakeBeginFrameSource* source1_;
   FakeBeginFrameSource* source2_;
   FakeBeginFrameSource* source3_;
 
  private:
@@ skipping 165 matching lines @@
   mux_->SetActiveSource(source2_);
   SEND_BEGIN_FRAME_DROP(*source2_, 750, 1050, 300);
   SEND_BEGIN_FRAME_USED(*source2_, 1050, 1250, 300);
 
   mux_->SetActiveSource(source1_);
   SEND_BEGIN_FRAME_DROP(*source2_, 1100, 1400, 300);
 }
 
 }  // namespace
 }  // namespace cc