replace OVERRIDE and FINAL with override and final in cc/

cc/resources/task_graph_runner_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 "cc/resources/task_graph_runner.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/synchronization/lock.h"
@@ skipping 100 matching lines @@
     tasks_[namespace_index].swap(new_tasks);
   }
 
  protected:
   class FakeTaskImpl : public Task {
    public:
     FakeTaskImpl(TaskGraphRunnerTestBase* test, int namespace_index, int id)
         : test_(test), namespace_index_(namespace_index), id_(id) {}
 
     // Overridden from Task:
-    virtual void RunOnWorkerThread() OVERRIDE {
+    virtual void RunOnWorkerThread() override {
       test_->RunTaskOnWorkerThread(namespace_index_, id_);
     }
 
     virtual void CompleteOnOriginThread() {
       test_->OnTaskCompleted(namespace_index_, id_);
     }
 
    protected:
     virtual ~FakeTaskImpl() {}
 
    private:
     TaskGraphRunnerTestBase* test_;
     int namespace_index_;
     int id_;
 
     DISALLOW_COPY_AND_ASSIGN(FakeTaskImpl);
   };
 
   class FakeDependentTaskImpl : public FakeTaskImpl {
    public:
     FakeDependentTaskImpl(TaskGraphRunnerTestBase* test,
                           int namespace_index,
                           int id)
         : FakeTaskImpl(test, namespace_index, id) {}
 
     // Overridden from FakeTaskImpl:
-    virtual void CompleteOnOriginThread() OVERRIDE {}
+    virtual void CompleteOnOriginThread() override {}
 
    private:
     virtual ~FakeDependentTaskImpl() {}
 
     DISALLOW_COPY_AND_ASSIGN(FakeDependentTaskImpl);
   };
 
   scoped_ptr<TaskGraphRunner> task_graph_runner_;
   NamespaceToken namespace_token_[kNamespaceCount];
   Task::Vector tasks_[kNamespaceCount];
   Task::Vector dependents_[kNamespaceCount];
   std::vector<unsigned> run_task_ids_[kNamespaceCount];
   base::Lock run_task_ids_lock_;
   std::vector<unsigned> on_task_completed_ids_[kNamespaceCount];
 };
 
 class TaskGraphRunnerTest : public TaskGraphRunnerTestBase,
                             public testing::TestWithParam<int>,
                             public base::DelegateSimpleThread::Delegate {
  public:
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     const size_t num_threads = GetParam();
     while (workers_.size() < num_threads) {
       scoped_ptr<base::DelegateSimpleThread> worker =
           make_scoped_ptr(new base::DelegateSimpleThread(this, "TestWorker"));
       worker->Start();
       workers_.push_back(worker.Pass());
     }
 
     for (int i = 0; i < kNamespaceCount; ++i)
       namespace_token_[i] = task_graph_runner_->GetNamespaceToken();
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     task_graph_runner_->Shutdown();
     while (workers_.size()) {
       scoped_ptr<base::DelegateSimpleThread> worker = workers_.take_front();
       worker->Join();
     }
   }
 
  private:
   // Overridden from base::DelegateSimpleThread::Delegate:
-  virtual void Run() OVERRIDE { task_graph_runner_->Run(); }
+  virtual void Run() override { task_graph_runner_->Run(); }
 
   ScopedPtrDeque<base::DelegateSimpleThread> workers_;
 };
 
 TEST_P(TaskGraphRunnerTest, Basic) {
   for (int i = 0; i < kNamespaceCount; ++i) {
     EXPECT_EQ(0u, run_task_ids(i).size());
     EXPECT_EQ(0u, on_task_completed_ids(i).size());
 
     ScheduleTasks(i, std::vector<TaskInfo>(1, TaskInfo(i, 0u, 0u, 0u, 0u)));
@@ skipping 75 matching lines @@
 INSTANTIATE_TEST_CASE_P(TaskGraphRunnerTests,
                         TaskGraphRunnerTest,
                         ::testing::Range(1, 5));
 
 class TaskGraphRunnerSingleThreadTest
     : public TaskGraphRunnerTestBase,
       public testing::Test,
       public base::DelegateSimpleThread::Delegate {
  public:
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     worker_.reset(new base::DelegateSimpleThread(this, "TestWorker"));
     worker_->Start();
 
     for (int i = 0; i < kNamespaceCount; ++i)
       namespace_token_[i] = task_graph_runner_->GetNamespaceToken();
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     task_graph_runner_->Shutdown();
     worker_->Join();
   }
 
  private:
   // Overridden from base::DelegateSimpleThread::Delegate:
-  virtual void Run() OVERRIDE { task_graph_runner_->Run(); }
+  virtual void Run() override { task_graph_runner_->Run(); }
 
   scoped_ptr<base::DelegateSimpleThread> worker_;
 };
 
 TEST_F(TaskGraphRunnerSingleThreadTest, Priority) {
   for (int i = 0; i < kNamespaceCount; ++i) {
     TaskInfo tasks[] = {TaskInfo(i, 0u, 2u, 1u, 1u),  // Priority 1
                         TaskInfo(i, 1u, 3u, 1u, 0u)   // Priority 0
     };
     ScheduleTasks(i, std::vector<TaskInfo>(tasks, tasks + arraysize(tasks)));
   }
 
   for (int i = 0; i < kNamespaceCount; ++i) {
     RunAllTasks(i);
 
     // Check if tasks ran in order of priority.
     ASSERT_EQ(4u, run_task_ids(i).size());
     EXPECT_EQ(1u, run_task_ids(i)[0]);
     EXPECT_EQ(3u, run_task_ids(i)[1]);
     EXPECT_EQ(0u, run_task_ids(i)[2]);
     EXPECT_EQ(2u, run_task_ids(i)[3]);
     ASSERT_EQ(2u, on_task_completed_ids(i).size());
     EXPECT_EQ(1u, on_task_completed_ids(i)[0]);
     EXPECT_EQ(0u, on_task_completed_ids(i)[1]);
   }
 }
 
 }  // namespace
 }  // namespace cc