replace OVERRIDE and FINAL with override and final in cc/

cc/resources/raster_worker_pool_perftest.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 "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "cc/debug/lap_timer.h"
 #include "cc/output/context_provider.h"
@@ skipping 17 matching lines @@
 #include "third_party/khronos/GLES2/gl2.h"
 
 namespace cc {
 namespace {
 
 class PerfGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
   // Overridden from gpu::gles2::GLES2Interface:
   virtual GLuint CreateImageCHROMIUM(GLsizei width,
                                      GLsizei height,
                                      GLenum internalformat,
-                                     GLenum usage) OVERRIDE {
+                                     GLenum usage) override {
     return 1u;
   }
-  virtual void GenBuffers(GLsizei n, GLuint* buffers) OVERRIDE {
+  virtual void GenBuffers(GLsizei n, GLuint* buffers) override {
     for (GLsizei i = 0; i < n; ++i)
       buffers[i] = 1u;
   }
-  virtual void GenTextures(GLsizei n, GLuint* textures) OVERRIDE {
+  virtual void GenTextures(GLsizei n, GLuint* textures) override {
     for (GLsizei i = 0; i < n; ++i)
       textures[i] = 1u;
   }
-  virtual void GetIntegerv(GLenum pname, GLint* params) OVERRIDE {
+  virtual void GetIntegerv(GLenum pname, GLint* params) override {
     if (pname == GL_MAX_TEXTURE_SIZE)
       *params = INT_MAX;
   }
-  virtual void GenQueriesEXT(GLsizei n, GLuint* queries) OVERRIDE {
+  virtual void GenQueriesEXT(GLsizei n, GLuint* queries) override {
     for (GLsizei i = 0; i < n; ++i)
       queries[i] = 1u;
   }
   virtual void GetQueryObjectuivEXT(GLuint query,
                                     GLenum pname,
-                                    GLuint* params) OVERRIDE {
+                                    GLuint* params) override {
     if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
       *params = 1;
   }
 };
 
 class PerfContextProvider : public ContextProvider {
  public:
   PerfContextProvider() : context_gl_(new PerfGLES2Interface) {}
 
-  virtual bool BindToCurrentThread() OVERRIDE { return true; }
-  virtual Capabilities ContextCapabilities() OVERRIDE {
+  virtual bool BindToCurrentThread() override { return true; }
+  virtual Capabilities ContextCapabilities() override {
     Capabilities capabilities;
     capabilities.gpu.image = true;
     capabilities.gpu.sync_query = true;
     return capabilities;
   }
-  virtual gpu::gles2::GLES2Interface* ContextGL() OVERRIDE {
+  virtual gpu::gles2::GLES2Interface* ContextGL() override {
     return context_gl_.get();
   }
-  virtual gpu::ContextSupport* ContextSupport() OVERRIDE { return &support_; }
-  virtual class GrContext* GrContext() OVERRIDE { return NULL; }
-  virtual bool IsContextLost() OVERRIDE { return false; }
-  virtual void VerifyContexts() OVERRIDE {}
-  virtual void DeleteCachedResources() OVERRIDE {}
-  virtual bool DestroyedOnMainThread() OVERRIDE { return false; }
-  virtual void SetLostContextCallback(const LostContextCallback& cb) OVERRIDE {}
+  virtual gpu::ContextSupport* ContextSupport() override { return &support_; }
+  virtual class GrContext* GrContext() override { return NULL; }
+  virtual bool IsContextLost() override { return false; }
+  virtual void VerifyContexts() override {}
+  virtual void DeleteCachedResources() override {}
+  virtual bool DestroyedOnMainThread() override { return false; }
+  virtual void SetLostContextCallback(const LostContextCallback& cb) override {}
   virtual void SetMemoryPolicyChangedCallback(
-      const MemoryPolicyChangedCallback& cb) OVERRIDE {}
+      const MemoryPolicyChangedCallback& cb) override {}
 
  private:
   virtual ~PerfContextProvider() {}
 
   scoped_ptr<PerfGLES2Interface> context_gl_;
   TestContextSupport support_;
 };
 
 enum RasterWorkerPoolType {
   RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
   RASTER_WORKER_POOL_TYPE_ZERO_COPY,
   RASTER_WORKER_POOL_TYPE_ONE_COPY,
   RASTER_WORKER_POOL_TYPE_GPU,
   RASTER_WORKER_POOL_TYPE_BITMAP
 };
 
 static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
 class PerfImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   PerfImageDecodeTaskImpl() {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {}
+  virtual void RunOnWorkerThread() override {}
 
   // Overridden from RasterizerTask:
-  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
-  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
-  virtual void RunReplyOnOriginThread() OVERRIDE { Reset(); }
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) override {}
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) override {}
+  virtual void RunReplyOnOriginThread() override { Reset(); }
 
   void Reset() {
     did_run_ = false;
     did_complete_ = false;
   }
 
  protected:
   virtual ~PerfImageDecodeTaskImpl() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl);
 };
 
 class PerfRasterTaskImpl : public RasterTask {
  public:
   PerfRasterTaskImpl(scoped_ptr<ScopedResource> resource,
                      ImageDecodeTask::Vector* dependencies)
       : RasterTask(resource.get(), dependencies), resource_(resource.Pass()) {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {}
+  virtual void RunOnWorkerThread() override {}
 
   // Overridden from RasterizerTask:
-  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) override {
     raster_buffer_ = client->AcquireBufferForRaster(resource());
   }
-  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) override {
     client->ReleaseBufferForRaster(raster_buffer_.Pass());
   }
-  virtual void RunReplyOnOriginThread() OVERRIDE { Reset(); }
+  virtual void RunReplyOnOriginThread() override { Reset(); }
 
   void Reset() {
     did_run_ = false;
     did_complete_ = false;
   }
 
  protected:
   virtual ~PerfRasterTaskImpl() {}
 
  private:
@@ skipping 61 matching lines @@
   scoped_ptr<TaskGraphRunner> task_graph_runner_;
   LapTimer timer_;
 };
 
 class RasterWorkerPoolPerfTest
     : public RasterWorkerPoolPerfTestBase,
       public testing::TestWithParam<RasterWorkerPoolType>,
       public RasterizerClient {
  public:
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     switch (GetParam()) {
       case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
         Create3dOutputSurfaceAndResourceProvider();
         raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
             task_runner_.get(),
             task_graph_runner_.get(),
             context_provider_.get(),
             resource_provider_.get(),
             std::numeric_limits<size_t>::max());
         break;
@@ skipping 27 matching lines @@
         raster_worker_pool_ =
             BitmapRasterWorkerPool::Create(task_runner_.get(),
                                            task_graph_runner_.get(),
                                            resource_provider_.get());
         break;
     }
 
     DCHECK(raster_worker_pool_);
     raster_worker_pool_->AsRasterizer()->SetClient(this);
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     raster_worker_pool_->AsRasterizer()->Shutdown();
     raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
   }
 
   // Overriden from RasterizerClient:
-  virtual void DidFinishRunningTasks(TaskSet task_set) OVERRIDE {
+  virtual void DidFinishRunningTasks(TaskSet task_set) override {
     raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
   }
-  virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const OVERRIDE {
+  virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const override {
     return TaskSetCollection();
   }
 
   void RunMessageLoopUntilAllTasksHaveCompleted() {
     task_graph_runner_->RunUntilIdle();
     task_runner_->RunUntilIdle();
   }
 
   void RunScheduleTasksTest(const std::string& test_name,
                             unsigned num_raster_tasks,
@@ skipping 173 matching lines @@
                         ::testing::Values(RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
                                           RASTER_WORKER_POOL_TYPE_ZERO_COPY,
                                           RASTER_WORKER_POOL_TYPE_ONE_COPY,
                                           RASTER_WORKER_POOL_TYPE_GPU,
                                           RASTER_WORKER_POOL_TYPE_BITMAP));
 
 class RasterWorkerPoolCommonPerfTest : public RasterWorkerPoolPerfTestBase,
                                        public testing::Test {
  public:
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     resource_provider_ =
         ResourceProvider::Create(
             output_surface_.get(), NULL, NULL, 0, false, 1, false).Pass();
   }
 
   void RunBuildRasterTaskQueueTest(const std::string& test_name,
                                    unsigned num_raster_tasks,
                                    unsigned num_image_decode_tasks) {
@@ skipping 25 matching lines @@
   RunBuildRasterTaskQueueTest("1_0", 1, 0);
   RunBuildRasterTaskQueueTest("32_0", 32, 0);
   RunBuildRasterTaskQueueTest("1_1", 1, 1);
   RunBuildRasterTaskQueueTest("32_1", 32, 1);
   RunBuildRasterTaskQueueTest("1_4", 1, 4);
   RunBuildRasterTaskQueueTest("32_4", 32, 4);
 }
 
 }  // namespace
 }  // namespace cc