Standardize usage of virtual/override/final in cc/

cc/resources/raster_worker_pool.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 "cc/resources/raster_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
@@ skipping 18 matching lines @@
                                  static_cast<unsigned>(workers_.size() + 1))
                   .c_str()));
       worker->Start();
 #if defined(OS_ANDROID) || defined(OS_LINUX)
       worker->SetThreadPriority(base::kThreadPriority_Background);
 #endif
       workers_.push_back(worker.Pass());
     }
   }
 
-  virtual ~RasterTaskGraphRunner() { NOTREACHED(); }
+  ~RasterTaskGraphRunner() override { NOTREACHED(); }
 
  private:
   // Overridden from base::DelegateSimpleThread::Delegate:
-  virtual void Run() override {
-    TaskGraphRunner::Run();
-  }
+  void Run() override { TaskGraphRunner::Run(); }
 
   ScopedPtrDeque<base::DelegateSimpleThread> workers_;
 };
 
 base::LazyInstance<RasterTaskGraphRunner>::Leaky g_task_graph_runner =
     LAZY_INSTANCE_INITIALIZER;
 
 const int kDefaultNumRasterThreads = 1;
 
 int g_num_raster_threads = 0;
 
 class RasterFinishedTaskImpl : public RasterizerTask {
  public:
   explicit RasterFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
       const base::Closure& on_raster_finished_callback)
       : task_runner_(task_runner),
         on_raster_finished_callback_(on_raster_finished_callback) {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() override {
+  void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "RasterFinishedTaskImpl::RunOnWorkerThread");
     RasterFinished();
   }
 
   // Overridden from RasterizerTask:
-  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) override {}
-  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) override {}
-  virtual void RunReplyOnOriginThread() override {}
+  void ScheduleOnOriginThread(RasterizerTaskClient* client) override {}
+  void CompleteOnOriginThread(RasterizerTaskClient* client) override {}
+  void RunReplyOnOriginThread() override {}
 
  protected:
-  virtual ~RasterFinishedTaskImpl() {}
+  ~RasterFinishedTaskImpl() override {}
 
   void RasterFinished() {
     task_runner_->PostTask(FROM_HERE, on_raster_finished_callback_);
   }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   const base::Closure on_raster_finished_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterFinishedTaskImpl);
@@ skipping 149 matching lines @@
     // bitmap data. There will be no need to call SkAlign4 once crbug.com/293728
     // is fixed.
     const size_t dst_row_bytes = SkAlign4(dst_info.minRowBytes());
     DCHECK_EQ(0u, dst_row_bytes % 4);
     bool success = bitmap.readPixels(dst_info, memory, dst_row_bytes, 0, 0);
     DCHECK_EQ(true, success);
   }
 }
 
 }  // namespace cc