Standardize usage of virtual/override/final specifiers.

content/renderer/scheduler/task_queue_manager.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 "content/renderer/scheduler/task_queue_manager.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "content/renderer/scheduler/task_queue_selector.h"
 
 namespace content {
 namespace internal {
 
 class TaskQueue : public base::SingleThreadTaskRunner {
  public:
   TaskQueue(TaskQueueManager* task_queue_manager);
 
   // base::SingleThreadTaskRunner implementation.
-  virtual bool RunsTasksOnCurrentThread() const override;
-  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
-                               const base::Closure& task,
-                               base::TimeDelta delay) override;
-  virtual bool PostNonNestableDelayedTask(
-      const tracked_objects::Location& from_here,
-      const base::Closure& task,
-      base::TimeDelta delay) override;
+  bool RunsTasksOnCurrentThread() const override;
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       const base::Closure& task,
+                       base::TimeDelta delay) override;
+  bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
+                                  const base::Closure& task,
+                                  base::TimeDelta delay) override;
 
   // Adds a task at the end of the incoming task queue and schedules a call to
   // TaskQueueManager::DoWork() if the incoming queue was empty and automatic
   // pumping is enabled. Can be called on an arbitrary thread.
   void EnqueueTask(const base::PendingTask& pending_task);
 
   bool IsQueueEmpty() const;
 
   void SetAutoPump(bool auto_pump);
   void PumpQueue();
 
   bool UpdateWorkQueue();
   base::PendingTask TakeTaskFromWorkQueue();
 
   void WillDeleteTaskQueueManager();
 
   base::TaskQueue& work_queue() { return work_queue_; }
 
  private:
-  virtual ~TaskQueue();
+  ~TaskQueue() override;
 
   void PumpQueueLocked();
   void EnqueueTaskLocked(const base::PendingTask& pending_task);
 
   // This lock protects all members except the work queue.
   mutable base::Lock lock_;
   TaskQueueManager* task_queue_manager_;
   base::TaskQueue incoming_queue_;
   bool auto_pump_;
 
@@ skipping 229 matching lines @@
 
 bool TaskQueueManager::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     base::TimeDelta delay) {
   // Defer non-nestable work to the main task runner.
   return main_task_runner_->PostNonNestableDelayedTask(from_here, task, delay);
 }
 
 }  // namespace content