Standardize usage of virtual/override/final in gpu/

gpu/command_buffer/service/async_pixel_transfer_manager_share_group.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 "gpu/command_buffer/service/async_pixel_transfer_manager_share_group.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 33 matching lines @@
  public:
   TransferThread()
       : base::Thread(kAsyncTransferThreadName),
         initialized_(false) {
     Start();
 #if defined(OS_ANDROID) || defined(OS_LINUX)
     SetPriority(base::kThreadPriority_Background);
 #endif
   }
 
-  virtual ~TransferThread() {
+  ~TransferThread() override {
     // The only instance of this class was declared leaky.
     NOTREACHED();
   }
 
   void InitializeOnMainThread(gfx::GLContext* parent_context) {
     TRACE_EVENT0("gpu", "TransferThread::InitializeOnMainThread");
     if (initialized_)
       return;
 
     base::WaitableEvent wait_for_init(true, false);
     message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&TransferThread::InitializeOnTransferThread,
                  base::Unretained(this),
                  base::Unretained(parent_context),
                  &wait_for_init));
     wait_for_init.Wait();
   }
 
-  virtual void CleanUp() override {
+  void CleanUp() override {
     surface_ = NULL;
     context_ = NULL;
   }
 
  private:
   bool initialized_;
 
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_refptr<gfx::GLContext> context_;
 
@@ skipping 285 matching lines @@
 }  // namespace
 
 class AsyncPixelTransferDelegateShareGroup
     : public AsyncPixelTransferDelegate,
       public base::SupportsWeakPtr<AsyncPixelTransferDelegateShareGroup> {
  public:
   AsyncPixelTransferDelegateShareGroup(
       AsyncPixelTransferManagerShareGroup::SharedState* shared_state,
       GLuint texture_id,
       const AsyncTexImage2DParams& define_params);
-  virtual ~AsyncPixelTransferDelegateShareGroup();
+  ~AsyncPixelTransferDelegateShareGroup() override;
 
   void BindTransfer() { state_->BindTransfer(); }
 
   // Implement AsyncPixelTransferDelegate:
-  virtual void AsyncTexImage2D(
-      const AsyncTexImage2DParams& tex_params,
-      const AsyncMemoryParams& mem_params,
-      const base::Closure& bind_callback) override;
-  virtual void AsyncTexSubImage2D(
-      const AsyncTexSubImage2DParams& tex_params,
-      const AsyncMemoryParams& mem_params) override;
-  virtual bool TransferIsInProgress() override;
-  virtual void WaitForTransferCompletion() override;
+  void AsyncTexImage2D(const AsyncTexImage2DParams& tex_params,
+                       const AsyncMemoryParams& mem_params,
+                       const base::Closure& bind_callback) override;
+  void AsyncTexSubImage2D(const AsyncTexSubImage2DParams& tex_params,
+                          const AsyncMemoryParams& mem_params) override;
+  bool TransferIsInProgress() override;
+  void WaitForTransferCompletion() override;
 
  private:
   // A raw pointer is safe because the SharedState is owned by the Manager,
   // which owns this Delegate.
   AsyncPixelTransferManagerShareGroup::SharedState* shared_state_;
   scoped_refptr<TransferStateInternal> state_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateShareGroup);
 };
 
@@ skipping 142 matching lines @@
 
 AsyncPixelTransferDelegate*
 AsyncPixelTransferManagerShareGroup::CreatePixelTransferDelegateImpl(
     gles2::TextureRef* ref,
     const AsyncTexImage2DParams& define_params) {
   return new AsyncPixelTransferDelegateShareGroup(
       &shared_state_, ref->service_id(), define_params);
 }
 
 }  // namespace gpu