Standardize usage of virtual/override/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 {
+    void RunOnWorkerThread() override {
       test_->RunTaskOnWorkerThread(namespace_index_, id_);
     }
 
     virtual void CompleteOnOriginThread() {
       test_->OnTaskCompleted(namespace_index_, id_);
     }
 
    protected:
-    virtual ~FakeTaskImpl() {}
+    ~FakeTaskImpl() override {}
 
    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 {}
+    void CompleteOnOriginThread() override {}
 
    private:
-    virtual ~FakeDependentTaskImpl() {}
+    ~FakeDependentTaskImpl() override {}
 
     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_;
@@ skipping 20 matching lines @@
   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(); }
+  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 89 matching lines @@
     for (int i = 0; i < kNamespaceCount; ++i)
       namespace_token_[i] = task_graph_runner_->GetNamespaceToken();
   }
   virtual void TearDown() override {
     task_graph_runner_->Shutdown();
     worker_->Join();
   }
 
  private:
   // Overridden from base::DelegateSimpleThread::Delegate:
-  virtual void Run() override { task_graph_runner_->Run(); }
+  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