Standardize usage of virtual/override/final in gpu/

This patch was automatically generated by applying clang fixit hints
generated by the plugin to the source tree.

The generator for the GLES2 command buffers has also been updated.

BUG=417463
TBR=piman@chromium.org

Review URL: https://codereview.chromium.org/663363002

Cr-Commit-Position: refs/heads/master@{#300496}

35 files changed, 459 insertions, 538 deletions

diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager.h b/gpu/command_buffer/service/async_pixel_transfer_manager.h
index 66b8bf7..3f52e1e 100644
--- a/gpu/command_buffer/service/async_pixel_transfer_manager.h
+++ b/gpu/command_buffer/service/async_pixel_transfer_manager.h
@@ -45,7 +45,7 @@ class GPU_EXPORT AsyncPixelTransferManager
  public:
   static AsyncPixelTransferManager* Create(gfx::GLContext* context);
 
-  virtual ~AsyncPixelTransferManager();
+  ~AsyncPixelTransferManager() override;
 
   void Initialize(gles2::TextureManager* texture_manager);
 
@@ -82,9 +82,8 @@ class GPU_EXPORT AsyncPixelTransferManager
   bool AsyncTransferIsInProgress(gles2::TextureRef* ref);
 
   // gles2::TextureRef::DestructionObserver implementation:
-  virtual void OnTextureManagerDestroying(gles2::TextureManager* manager)
-      override;
-  virtual void OnTextureRefDestroying(gles2::TextureRef* texture) override;
+  void OnTextureManagerDestroying(gles2::TextureManager* manager) override;
+  void OnTextureRefDestroying(gles2::TextureRef* texture) override;
 
  protected:
   AsyncPixelTransferManager();
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_idle.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_idle.cc
index c43491d3..61db3b6 100644
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_idle.cc
+++ b/gpu/command_buffer/service/async_pixel_transfer_manager_idle.cc
@@ -36,18 +36,16 @@ class AsyncPixelTransferDelegateIdle
       AsyncPixelTransferManagerIdle::SharedState* state,
       GLuint texture_id,
       const AsyncTexImage2DParams& define_params);
-  virtual ~AsyncPixelTransferDelegateIdle();
+  ~AsyncPixelTransferDelegateIdle() override;
 
   // 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:
   void PerformAsyncTexImage2D(AsyncTexImage2DParams tex_params,
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_idle.h b/gpu/command_buffer/service/async_pixel_transfer_manager_idle.h
index 0ec950c..8aba7ff 100644
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_idle.h
+++ b/gpu/command_buffer/service/async_pixel_transfer_manager_idle.h
@@ -14,18 +14,18 @@ namespace gpu {
 class AsyncPixelTransferManagerIdle : public AsyncPixelTransferManager {
  public:
   AsyncPixelTransferManagerIdle();
-  virtual ~AsyncPixelTransferManagerIdle();
+  ~AsyncPixelTransferManagerIdle() override;
 
   // AsyncPixelTransferManager implementation:
-  virtual void BindCompletedAsyncTransfers() override;
-  virtual void AsyncNotifyCompletion(
+  void BindCompletedAsyncTransfers() override;
+  void AsyncNotifyCompletion(
       const AsyncMemoryParams& mem_params,
       AsyncPixelTransferCompletionObserver* observer) override;
-  virtual uint32 GetTextureUploadCount() override;
-  virtual base::TimeDelta GetTotalTextureUploadTime() override;
-  virtual void ProcessMorePendingTransfers() override;
-  virtual bool NeedsProcessMorePendingTransfers() override;
-  virtual void WaitAllAsyncTexImage2D() override;
+  uint32 GetTextureUploadCount() override;
+  base::TimeDelta GetTotalTextureUploadTime() override;
+  void ProcessMorePendingTransfers() override;
+  bool NeedsProcessMorePendingTransfers() override;
+  void WaitAllAsyncTexImage2D() override;
 
   struct Task {
     Task(uint64 transfer_id,
@@ -54,7 +54,7 @@ class AsyncPixelTransferManagerIdle : public AsyncPixelTransferManager {
 
  private:
   // AsyncPixelTransferManager implementation:
-  virtual AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
+  AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
       gles2::TextureRef* ref,
       const AsyncTexImage2DParams& define_params) override;
 
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc
index e28ff82..b6506bf 100644
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc
+++ b/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc
@@ -51,7 +51,7 @@ class TransferThread : public base::Thread {
 #endif
   }
 
-  virtual ~TransferThread() {
+  ~TransferThread() override {
     // The only instance of this class was declared leaky.
     NOTREACHED();
   }
@@ -71,7 +71,7 @@ class TransferThread : public base::Thread {
     wait_for_init.Wait();
   }
 
-  virtual void CleanUp() override {
+  void CleanUp() override {
     surface_ = NULL;
     context_ = NULL;
   }
@@ -377,20 +377,18 @@ class 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,
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.h b/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.h
index 9f9f04e..081fcc4 100644
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.h
+++ b/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.h
@@ -20,18 +20,18 @@ class AsyncPixelTransferUploadStats;
 class AsyncPixelTransferManagerShareGroup : public AsyncPixelTransferManager {
  public:
   explicit AsyncPixelTransferManagerShareGroup(gfx::GLContext* context);
-  virtual ~AsyncPixelTransferManagerShareGroup();
+  ~AsyncPixelTransferManagerShareGroup() override;
 
   // AsyncPixelTransferManager implementation:
-  virtual void BindCompletedAsyncTransfers() override;
-  virtual void AsyncNotifyCompletion(
+  void BindCompletedAsyncTransfers() override;
+  void AsyncNotifyCompletion(
       const AsyncMemoryParams& mem_params,
       AsyncPixelTransferCompletionObserver* observer) override;
-  virtual uint32 GetTextureUploadCount() override;
-  virtual base::TimeDelta GetTotalTextureUploadTime() override;
-  virtual void ProcessMorePendingTransfers() override;
-  virtual bool NeedsProcessMorePendingTransfers() override;
-  virtual void WaitAllAsyncTexImage2D() override;
+  uint32 GetTextureUploadCount() override;
+  base::TimeDelta GetTotalTextureUploadTime() override;
+  void ProcessMorePendingTransfers() override;
+  bool NeedsProcessMorePendingTransfers() override;
+  void WaitAllAsyncTexImage2D() override;
 
   // State shared between Managers and Delegates.
   struct SharedState {
@@ -46,7 +46,7 @@ class AsyncPixelTransferManagerShareGroup : public AsyncPixelTransferManager {
 
  private:
   // AsyncPixelTransferManager implementation:
-  virtual AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
+  AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
       gles2::TextureRef* ref,
       const AsyncTexImage2DParams& define_params) override;
 
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_stub.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_stub.cc
index 4b8ce1d..a2fbc8e 100644
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_stub.cc
+++ b/gpu/command_buffer/service/async_pixel_transfer_manager_stub.cc
@@ -11,18 +11,16 @@ namespace gpu {
 class AsyncPixelTransferDelegateStub : public AsyncPixelTransferDelegate {
  public:
   AsyncPixelTransferDelegateStub();
-  virtual ~AsyncPixelTransferDelegateStub();
+  ~AsyncPixelTransferDelegateStub() override;
 
   // 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:
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateStub);
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_stub.h b/gpu/command_buffer/service/async_pixel_transfer_manager_stub.h
index c2fa3eb..f8ced57 100644
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_stub.h
+++ b/gpu/command_buffer/service/async_pixel_transfer_manager_stub.h
@@ -12,22 +12,22 @@ namespace gpu {
 class AsyncPixelTransferManagerStub : public AsyncPixelTransferManager {
  public:
   AsyncPixelTransferManagerStub();
-  virtual ~AsyncPixelTransferManagerStub();
+  ~AsyncPixelTransferManagerStub() override;
 
   // AsyncPixelTransferManager implementation:
-  virtual void BindCompletedAsyncTransfers() override;
-  virtual void AsyncNotifyCompletion(
+  void BindCompletedAsyncTransfers() override;
+  void AsyncNotifyCompletion(
       const AsyncMemoryParams& mem_params,
       AsyncPixelTransferCompletionObserver* observer) override;
-  virtual uint32 GetTextureUploadCount() override;
-  virtual base::TimeDelta GetTotalTextureUploadTime() override;
-  virtual void ProcessMorePendingTransfers() override;
-  virtual bool NeedsProcessMorePendingTransfers() override;
-  virtual void WaitAllAsyncTexImage2D() override;
+  uint32 GetTextureUploadCount() override;
+  base::TimeDelta GetTotalTextureUploadTime() override;
+  void ProcessMorePendingTransfers() override;
+  bool NeedsProcessMorePendingTransfers() override;
+  void WaitAllAsyncTexImage2D() override;
 
  private:
   // AsyncPixelTransferManager implementation:
-  virtual AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
+  AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
       gles2::TextureRef* ref,
       const AsyncTexImage2DParams& define_params) override;
 
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_sync.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_sync.cc
index b5851d2..4bc2ba2 100644
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_sync.cc
+++ b/gpu/command_buffer/service/async_pixel_transfer_manager_sync.cc
@@ -13,18 +13,16 @@ class AsyncPixelTransferDelegateSync : public AsyncPixelTransferDelegate {
  public:
   explicit AsyncPixelTransferDelegateSync(
       AsyncPixelTransferManagerSync::SharedState* shared_state);
-  virtual ~AsyncPixelTransferDelegateSync();
+  ~AsyncPixelTransferDelegateSync() override;
 
   // 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:
   // Safe to hold a raw pointer because SharedState is owned by the Manager
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_sync.h b/gpu/command_buffer/service/async_pixel_transfer_manager_sync.h
index a08e915..b965d6f 100644
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_sync.h
+++ b/gpu/command_buffer/service/async_pixel_transfer_manager_sync.h
@@ -12,18 +12,18 @@ namespace gpu {
 class AsyncPixelTransferManagerSync : public AsyncPixelTransferManager {
  public:
   AsyncPixelTransferManagerSync();
-  virtual ~AsyncPixelTransferManagerSync();
+  ~AsyncPixelTransferManagerSync() override;
 
   // AsyncPixelTransferManager implementation:
-  virtual void BindCompletedAsyncTransfers() override;
-  virtual void AsyncNotifyCompletion(
+  void BindCompletedAsyncTransfers() override;
+  void AsyncNotifyCompletion(
       const AsyncMemoryParams& mem_params,
       AsyncPixelTransferCompletionObserver* observer) override;
-  virtual uint32 GetTextureUploadCount() override;
-  virtual base::TimeDelta GetTotalTextureUploadTime() override;
-  virtual void ProcessMorePendingTransfers() override;
-  virtual bool NeedsProcessMorePendingTransfers() override;
-  virtual void WaitAllAsyncTexImage2D() override;
+  uint32 GetTextureUploadCount() override;
+  base::TimeDelta GetTotalTextureUploadTime() override;
+  void ProcessMorePendingTransfers() override;
+  bool NeedsProcessMorePendingTransfers() override;
+  void WaitAllAsyncTexImage2D() override;
 
   // State shared between Managers and Delegates.
   struct SharedState {
@@ -36,7 +36,7 @@ class AsyncPixelTransferManagerSync : public AsyncPixelTransferManager {
 
  private:
   // AsyncPixelTransferManager implementation:
-  virtual AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
+  AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
       gles2::TextureRef* ref,
       const AsyncTexImage2DParams& define_params) override;
 
diff --git a/gpu/command_buffer/service/command_buffer_service.h b/gpu/command_buffer/service/command_buffer_service.h
index e3e2ebd..15f865f 100644
--- a/gpu/command_buffer/service/command_buffer_service.h
+++ b/gpu/command_buffer/service/command_buffer_service.h
@@ -42,26 +42,25 @@ class GPU_EXPORT CommandBufferService : public CommandBufferServiceBase {
   typedef base::Callback<bool(int32)> GetBufferChangedCallback;
   explicit CommandBufferService(
       TransferBufferManagerInterface* transfer_buffer_manager);
-  virtual ~CommandBufferService();
+  ~CommandBufferService() override;
 
   // CommandBuffer implementation:
-  virtual bool Initialize() override;
-  virtual State GetLastState() override;
-  virtual int32 GetLastToken() override;
-  virtual void Flush(int32 put_offset) override;
-  virtual void WaitForTokenInRange(int32 start, int32 end) override;
-  virtual void WaitForGetOffsetInRange(int32 start, int32 end) override;
-  virtual void SetGetBuffer(int32 transfer_buffer_id) override;
-  virtual scoped_refptr<Buffer> CreateTransferBuffer(size_t size,
-                                                     int32* id) override;
-  virtual void DestroyTransferBuffer(int32 id) override;
+  bool Initialize() override;
+  State GetLastState() override;
+  int32 GetLastToken() override;
+  void Flush(int32 put_offset) override;
+  void WaitForTokenInRange(int32 start, int32 end) override;
+  void WaitForGetOffsetInRange(int32 start, int32 end) override;
+  void SetGetBuffer(int32 transfer_buffer_id) override;
+  scoped_refptr<Buffer> CreateTransferBuffer(size_t size, int32* id) override;
+  void DestroyTransferBuffer(int32 id) override;
 
   // CommandBufferServiceBase implementation:
-  virtual void SetGetOffset(int32 get_offset) override;
-  virtual scoped_refptr<Buffer> GetTransferBuffer(int32 id) override;
-  virtual void SetToken(int32 token) override;
-  virtual void SetParseError(error::Error error) override;
-  virtual void SetContextLostReason(error::ContextLostReason) override;
+  void SetGetOffset(int32 get_offset) override;
+  scoped_refptr<Buffer> GetTransferBuffer(int32 id) override;
+  void SetToken(int32 token) override;
+  void SetParseError(error::Error error) override;
+  void SetContextLostReason(error::ContextLostReason) override;
 
   // Sets a callback that is called whenever the put offset is changed. When
   // called with sync==true, the callback must not return until some progress
diff --git a/gpu/command_buffer/service/common_decoder.h b/gpu/command_buffer/service/common_decoder.h
index 2132afb..aaf860f 100644
--- a/gpu/command_buffer/service/common_decoder.h
+++ b/gpu/command_buffer/service/common_decoder.h
@@ -95,7 +95,7 @@ class GPU_EXPORT CommonDecoder : NON_EXPORTED_BASE(public AsyncAPIInterface) {
   };
 
   CommonDecoder();
-  virtual ~CommonDecoder();
+  ~CommonDecoder() override;
 
   // Sets the engine, to get shared memory buffers from, and to set the token
   // to.
diff --git a/gpu/command_buffer/service/common_decoder_unittest.cc b/gpu/command_buffer/service/common_decoder_unittest.cc
index cc965cd..aa1ed1b 100644
--- a/gpu/command_buffer/service/common_decoder_unittest.cc
+++ b/gpu/command_buffer/service/common_decoder_unittest.cc
@@ -51,15 +51,14 @@ TEST(CommonDecoderBucket, SetData) {
 class TestCommonDecoder : public CommonDecoder {
  public:
   // Overridden from AsyncAPIInterface
-  virtual const char* GetCommandName(unsigned int command_id) const override {
+  const char* GetCommandName(unsigned int command_id) const override {
     return GetCommonCommandName(static_cast<cmd::CommandId>(command_id));
   }
 
   // Overridden from AsyncAPIInterface
-  virtual error::Error DoCommand(
-      unsigned int command,
-      unsigned int arg_count,
-      const void* cmd_data) override {
+  error::Error DoCommand(unsigned int command,
+                         unsigned int arg_count,
+                         const void* cmd_data) override {
     return DoCommonCommand(command, arg_count, cmd_data);
   }
 
@@ -87,8 +86,7 @@ class MockCommandBufferEngine : public CommandBufferEngine {
   }
 
   // Overridden from CommandBufferEngine.
-  virtual scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id)
-      override {
+  scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id) override {
     if (IsValidSharedMemoryId(shm_id))
       return buffer_;
     return NULL;
@@ -110,22 +108,20 @@ class MockCommandBufferEngine : public CommandBufferEngine {
   }
 
   // Overridden from CommandBufferEngine.
-  virtual void set_token(int32 token) override {
-    token_ = token;
-  }
+  void set_token(int32 token) override { token_ = token; }
 
   int32 token() const {
     return token_;
   }
 
   // Overridden from CommandBufferEngine.
-  virtual bool SetGetBuffer(int32 transfer_buffer_id) override {
+  bool SetGetBuffer(int32 transfer_buffer_id) override {
     NOTREACHED();
     return false;
   }
 
   // Overridden from CommandBufferEngine.
-  virtual bool SetGetOffset(int32 offset) override {
+  bool SetGetOffset(int32 offset) override {
     if (static_cast<size_t>(offset) < kBufferSize) {
       get_offset_ = offset;
       return true;
@@ -134,9 +130,7 @@ class MockCommandBufferEngine : public CommandBufferEngine {
   }
 
   // Overridden from CommandBufferEngine.
-  virtual int32 GetGetOffset() override {
-    return get_offset_;
-  }
+  int32 GetGetOffset() override { return get_offset_; }
 
  private:
   bool IsValidSharedMemoryId(int32 shm_id) {
diff --git a/gpu/command_buffer/service/error_state.cc b/gpu/command_buffer/service/error_state.cc
index c71a159..42131aa 100644
--- a/gpu/command_buffer/service/error_state.cc
+++ b/gpu/command_buffer/service/error_state.cc
@@ -17,45 +17,44 @@ namespace gles2 {
 class ErrorStateImpl : public ErrorState {
  public:
   explicit ErrorStateImpl(ErrorStateClient* client, Logger* logger);
-  virtual ~ErrorStateImpl();
-
-  virtual uint32 GetGLError() override;
-
-  virtual void SetGLError(
-      const char* filename,
-      int line,
-      unsigned int error,
-      const char* function_name,
-      const char* msg) override;
-  virtual void SetGLErrorInvalidEnum(
-      const char* filename,
-      int line,
-      const char* function_name,
-      unsigned int value,
-      const char* label) override;
-  virtual void SetGLErrorInvalidParami(
-      const char* filename,
-      int line,
-      unsigned int error,
-      const char* function_name,
-      unsigned int pname,
-      int param) override;
-  virtual void SetGLErrorInvalidParamf(
-      const char* filename,
-      int line,
-      unsigned int error,
-      const char* function_name,
-      unsigned int pname,
-      float param) override;
-
-  virtual unsigned int PeekGLError(
-      const char* filename, int line, const char* function_name) override;
-
-  virtual void CopyRealGLErrorsToWrapper(
-      const char* filename, int line, const char* function_name) override;
-
-  virtual void ClearRealGLErrors(
-      const char* filename, int line, const char* function_name) override;
+  ~ErrorStateImpl() override;
+
+  uint32 GetGLError() override;
+
+  void SetGLError(const char* filename,
+                  int line,
+                  unsigned int error,
+                  const char* function_name,
+                  const char* msg) override;
+  void SetGLErrorInvalidEnum(const char* filename,
+                             int line,
+                             const char* function_name,
+                             unsigned int value,
+                             const char* label) override;
+  void SetGLErrorInvalidParami(const char* filename,
+                               int line,
+                               unsigned int error,
+                               const char* function_name,
+                               unsigned int pname,
+                               int param) override;
+  void SetGLErrorInvalidParamf(const char* filename,
+                               int line,
+                               unsigned int error,
+                               const char* function_name,
+                               unsigned int pname,
+                               float param) override;
+
+  unsigned int PeekGLError(const char* filename,
+                           int line,
+                           const char* function_name) override;
+
+  void CopyRealGLErrorsToWrapper(const char* filename,
+                                 int line,
+                                 const char* function_name) override;
+
+  void ClearRealGLErrors(const char* filename,
+                         int line,
+                         const char* function_name) override;
 
  private:
   // The last error message set.
diff --git a/gpu/command_buffer/service/framebuffer_manager.cc b/gpu/command_buffer/service/framebuffer_manager.cc
index 60f3ac9..d766abb 100644
--- a/gpu/command_buffer/service/framebuffer_manager.cc
+++ b/gpu/command_buffer/service/framebuffer_manager.cc
@@ -48,61 +48,42 @@ class RenderbufferAttachment
       : renderbuffer_(renderbuffer) {
   }
 
-  virtual GLsizei width() const override {
-    return renderbuffer_->width();
-  }
+  GLsizei width() const override { return renderbuffer_->width(); }
 
-  virtual GLsizei height() const override {
-    return renderbuffer_->height();
-  }
+  GLsizei height() const override { return renderbuffer_->height(); }
 
-  virtual GLenum internal_format() const override {
+  GLenum internal_format() const override {
     return renderbuffer_->internal_format();
   }
 
-  virtual GLenum texture_type() const override {
-    return 0;
-  }
+  GLenum texture_type() const override { return 0; }
 
-  virtual GLsizei samples() const override {
-    return renderbuffer_->samples();
-  }
+  GLsizei samples() const override { return renderbuffer_->samples(); }
 
-  virtual GLuint object_name() const override {
-    return renderbuffer_->client_id();
-  }
+  GLuint object_name() const override { return renderbuffer_->client_id(); }
 
-  virtual bool cleared() const override {
-    return renderbuffer_->cleared();
-  }
+  bool cleared() const override { return renderbuffer_->cleared(); }
 
-  virtual void SetCleared(
-      RenderbufferManager* renderbuffer_manager,
-      TextureManager* /* texture_manager */,
-      bool cleared) override {
+  void SetCleared(RenderbufferManager* renderbuffer_manager,
+                  TextureManager* /* texture_manager */,
+                  bool cleared) override {
     renderbuffer_manager->SetCleared(renderbuffer_.get(), cleared);
   }
 
-  virtual bool IsTexture(
-      TextureRef* /* texture */) const override {
-    return false;
-  }
+  bool IsTexture(TextureRef* /* texture */) const override { return false; }
 
-  virtual bool IsRenderbuffer(
-       Renderbuffer* renderbuffer) const override {
+  bool IsRenderbuffer(Renderbuffer* renderbuffer) const override {
     return renderbuffer_.get() == renderbuffer;
   }
 
-  virtual bool CanRenderTo() const override {
-    return true;
-  }
+  bool CanRenderTo() const override { return true; }
 
-  virtual void DetachFromFramebuffer(Framebuffer* framebuffer) const override {
+  void DetachFromFramebuffer(Framebuffer* framebuffer) const override {
     // Nothing to do for renderbuffers.
   }
 
-  virtual bool ValidForAttachmentType(
-      GLenum attachment_type, uint32 max_color_attachments) override {
+  bool ValidForAttachmentType(GLenum attachment_type,
+                              uint32 max_color_attachments) override {
     uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
         attachment_type, max_color_attachments);
     uint32 have = GLES2Util::GetChannelsForFormat(internal_format());
@@ -113,26 +94,25 @@ class RenderbufferAttachment
     return renderbuffer_.get();
   }
 
-  virtual size_t GetSignatureSize(
-      TextureManager* texture_manager) const override {
+  size_t GetSignatureSize(TextureManager* texture_manager) const override {
     return renderbuffer_->GetSignatureSize();
   }
 
-  virtual void AddToSignature(
-      TextureManager* texture_manager, std::string* signature) const override {
+  void AddToSignature(TextureManager* texture_manager,
+                      std::string* signature) const override {
     DCHECK(signature);
     renderbuffer_->AddToSignature(signature);
   }
 
-  virtual void OnWillRenderTo() const override {}
-  virtual void OnDidRenderTo() const override {}
-  virtual bool FormsFeedbackLoop(
-      TextureRef* /* texture */, GLint /*level */) const override {
+  void OnWillRenderTo() const override {}
+  void OnDidRenderTo() const override {}
+  bool FormsFeedbackLoop(TextureRef* /* texture */,
+                         GLint /*level */) const override {
     return false;
   }
 
  protected:
-  virtual ~RenderbufferAttachment() { }
+  ~RenderbufferAttachment() override {}
 
  private:
   scoped_refptr<Renderbuffer> renderbuffer_;
@@ -151,7 +131,7 @@ class TextureAttachment
         samples_(samples) {
   }
 
-  virtual GLsizei width() const override {
+  GLsizei width() const override {
     GLsizei temp_width = 0;
     GLsizei temp_height = 0;
     texture_ref_->texture()->GetLevelSize(
@@ -159,7 +139,7 @@ class TextureAttachment
     return temp_width;
   }
 
-  virtual GLsizei height() const override {
+  GLsizei height() const override {
     GLsizei temp_width = 0;
     GLsizei temp_height = 0;
     texture_ref_->texture()->GetLevelSize(
@@ -167,7 +147,7 @@ class TextureAttachment
     return temp_height;
   }
 
-  virtual GLenum internal_format() const override {
+  GLenum internal_format() const override {
     GLenum temp_type = 0;
     GLenum temp_internal_format = 0;
     texture_ref_->texture()->GetLevelType(
@@ -175,7 +155,7 @@ class TextureAttachment
     return temp_internal_format;
   }
 
-  virtual GLenum texture_type() const override {
+  GLenum texture_type() const override {
     GLenum temp_type = 0;
     GLenum temp_internal_format = 0;
     texture_ref_->texture()->GetLevelType(
@@ -183,33 +163,26 @@ class TextureAttachment
     return temp_type;
   }
 
-  virtual GLsizei samples() const override {
-    return samples_;
-  }
+  GLsizei samples() const override { return samples_; }
 
-  virtual GLuint object_name() const override {
-    return texture_ref_->client_id();
-  }
+  GLuint object_name() const override { return texture_ref_->client_id(); }
 
-  virtual bool cleared() const override {
+  bool cleared() const override {
     return texture_ref_->texture()->IsLevelCleared(target_, level_);
   }
 
-  virtual void SetCleared(
-      RenderbufferManager* /* renderbuffer_manager */,
-      TextureManager* texture_manager,
-      bool cleared) override {
+  void SetCleared(RenderbufferManager* /* renderbuffer_manager */,
+                  TextureManager* texture_manager,
+                  bool cleared) override {
     texture_manager->SetLevelCleared(
         texture_ref_.get(), target_, level_, cleared);
   }
 
-  virtual bool IsTexture(TextureRef* texture) const override {
+  bool IsTexture(TextureRef* texture) const override {
     return texture == texture_ref_.get();
   }
 
-  virtual bool IsRenderbuffer(
-       Renderbuffer* /* renderbuffer */)
-          const override {
+  bool IsRenderbuffer(Renderbuffer* /* renderbuffer */) const override {
     return false;
   }
 
@@ -217,18 +190,17 @@ class TextureAttachment
     return texture_ref_.get();
   }
 
-  virtual bool CanRenderTo() const override {
+  bool CanRenderTo() const override {
     return texture_ref_->texture()->CanRenderTo();
   }
 
-  virtual void DetachFromFramebuffer(Framebuffer* framebuffer)
-      const override {
+  void DetachFromFramebuffer(Framebuffer* framebuffer) const override {
     texture_ref_->texture()->DetachFromFramebuffer();
     framebuffer->OnTextureRefDetached(texture_ref_.get());
   }
 
-  virtual bool ValidForAttachmentType(
-      GLenum attachment_type, uint32 max_color_attachments) override {
+  bool ValidForAttachmentType(GLenum attachment_type,
+                              uint32 max_color_attachments) override {
     GLenum type = 0;
     GLenum internal_format = 0;
     if (!texture_ref_->texture()->GetLevelType(
@@ -248,33 +220,31 @@ class TextureAttachment
     return (need & have) != 0;
   }
 
-  virtual size_t GetSignatureSize(
-      TextureManager* texture_manager) const override {
+  size_t GetSignatureSize(TextureManager* texture_manager) const override {
     return texture_manager->GetSignatureSize();
   }
 
-  virtual void AddToSignature(
-      TextureManager* texture_manager, std::string* signature) const override {
+  void AddToSignature(TextureManager* texture_manager,
+                      std::string* signature) const override {
     DCHECK(signature);
     texture_manager->AddToSignature(
         texture_ref_.get(), target_, level_, signature);
   }
 
-  virtual void OnWillRenderTo() const override {
+  void OnWillRenderTo() const override {
     texture_ref_->texture()->OnWillModifyPixels();
   }
 
-  virtual void OnDidRenderTo() const override {
+  void OnDidRenderTo() const override {
     texture_ref_->texture()->OnDidModifyPixels();
   }
 
-  virtual bool FormsFeedbackLoop(
-      TextureRef* texture, GLint level) const override {
+  bool FormsFeedbackLoop(TextureRef* texture, GLint level) const override {
     return texture == texture_ref_.get() && level == level_;
   }
 
  protected:
-  virtual ~TextureAttachment() {}
+  ~TextureAttachment() override {}
 
  private:
   scoped_refptr<TextureRef> texture_ref_;
diff --git a/gpu/command_buffer/service/gl_context_virtual.h b/gpu/command_buffer/service/gl_context_virtual.h
index 76f4021..ed61016 100644
--- a/gpu/command_buffer/service/gl_context_virtual.h
+++ b/gpu/command_buffer/service/gl_context_virtual.h
@@ -34,23 +34,22 @@ class GPU_EXPORT GLContextVirtual : public gfx::GLContext {
   gfx::Display* display();
 
   // Implement GLContext.
-  virtual bool Initialize(
-      gfx::GLSurface* compatible_surface,
-      gfx::GpuPreference gpu_preference) override;
-  virtual void Destroy() override;
-  virtual bool MakeCurrent(gfx::GLSurface* surface) override;
-  virtual void ReleaseCurrent(gfx::GLSurface* surface) override;
-  virtual bool IsCurrent(gfx::GLSurface* surface) override;
-  virtual void* GetHandle() override;
-  virtual void SetSwapInterval(int interval) override;
-  virtual std::string GetExtensions() override;
-  virtual bool GetTotalGpuMemory(size_t* bytes) override;
-  virtual void SetSafeToForceGpuSwitch() override;
-  virtual bool WasAllocatedUsingRobustnessExtension() override;
-  virtual void SetUnbindFboOnMakeCurrent() override;
+  bool Initialize(gfx::GLSurface* compatible_surface,
+                  gfx::GpuPreference gpu_preference) override;
+  void Destroy() override;
+  bool MakeCurrent(gfx::GLSurface* surface) override;
+  void ReleaseCurrent(gfx::GLSurface* surface) override;
+  bool IsCurrent(gfx::GLSurface* surface) override;
+  void* GetHandle() override;
+  void SetSwapInterval(int interval) override;
+  std::string GetExtensions() override;
+  bool GetTotalGpuMemory(size_t* bytes) override;
+  void SetSafeToForceGpuSwitch() override;
+  bool WasAllocatedUsingRobustnessExtension() override;
+  void SetUnbindFboOnMakeCurrent() override;
 
  protected:
-  virtual ~GLContextVirtual();
+  ~GLContextVirtual() override;
 
  private:
   scoped_refptr<gfx::GLContext> shared_context_;
diff --git a/gpu/command_buffer/service/gl_state_restorer_impl.h b/gpu/command_buffer/service/gl_state_restorer_impl.h
index b8ccc44..91d3408 100644
--- a/gpu/command_buffer/service/gl_state_restorer_impl.h
+++ b/gpu/command_buffer/service/gl_state_restorer_impl.h
@@ -22,13 +22,13 @@ struct ContextState;
 class GPU_EXPORT GLStateRestorerImpl : public gfx::GLStateRestorer {
  public:
    explicit GLStateRestorerImpl(base::WeakPtr<gles2::GLES2Decoder> decoder);
-   virtual ~GLStateRestorerImpl();
+   ~GLStateRestorerImpl() override;
 
-   virtual bool IsInitialized() override;
-   virtual void RestoreState(const gfx::GLStateRestorer* prev_state) override;
-   virtual void RestoreAllTextureUnitBindings() override;
-   virtual void RestoreActiveTextureUnitBinding(unsigned int target) override;
-   virtual void RestoreFramebufferBindings() override;
+   bool IsInitialized() override;
+   void RestoreState(const gfx::GLStateRestorer* prev_state) override;
+   void RestoreAllTextureUnitBindings() override;
+   void RestoreActiveTextureUnitBinding(unsigned int target) override;
+   void RestoreFramebufferBindings() override;
 
  private:
    const gles2::ContextState* GetContextState() const;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 6253cc8..1bc8aad 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -511,7 +511,7 @@ class AsyncUploadTokenCompletionObserver
       : async_upload_token_(async_upload_token) {
   }
 
-  virtual void DidComplete(const AsyncMemoryParams& mem_params) override {
+  void DidComplete(const AsyncMemoryParams& mem_params) override {
     DCHECK(mem_params.buffer().get());
     void* data = mem_params.GetDataAddress();
     AsyncUploadSync* sync = static_cast<AsyncUploadSync*>(data);
@@ -519,8 +519,7 @@ class AsyncUploadTokenCompletionObserver
   }
 
  private:
-  virtual ~AsyncUploadTokenCompletionObserver() {
-  }
+  ~AsyncUploadTokenCompletionObserver() override {}
 
   uint32 async_upload_token_;
 
@@ -558,17 +557,17 @@ class GLES2DecoderImpl : public GLES2Decoder,
                          public ErrorStateClient {
  public:
   explicit GLES2DecoderImpl(ContextGroup* group);
-  virtual ~GLES2DecoderImpl();
+  ~GLES2DecoderImpl() override;
 
   // Overridden from AsyncAPIInterface.
-  virtual Error DoCommand(unsigned int command,
-                          unsigned int arg_count,
-                          const void* args) override;
+  Error DoCommand(unsigned int command,
+                  unsigned int arg_count,
+                  const void* args) override;
 
-  virtual error::Error DoCommands(unsigned int num_commands,
-                                  const void* buffer,
-                                  int num_entries,
-                                  int* entries_processed) override;
+  error::Error DoCommands(unsigned int num_commands,
+                          const void* buffer,
+                          int num_entries,
+                          int* entries_processed) override;
 
   template <bool DebugImpl>
   error::Error DoCommandsImpl(unsigned int num_commands,
@@ -577,104 +576,91 @@ class GLES2DecoderImpl : public GLES2Decoder,
                               int* entries_processed);
 
   // Overridden from AsyncAPIInterface.
-  virtual const char* GetCommandName(unsigned int command_id) const override;
+  const char* GetCommandName(unsigned int command_id) const override;
 
   // Overridden from GLES2Decoder.
-  virtual bool Initialize(const scoped_refptr<gfx::GLSurface>& surface,
-                          const scoped_refptr<gfx::GLContext>& context,
-                          bool offscreen,
-                          const gfx::Size& size,
-                          const DisallowedFeatures& disallowed_features,
-                          const std::vector<int32>& attribs) override;
-  virtual void Destroy(bool have_context) override;
-  virtual void SetSurface(
-      const scoped_refptr<gfx::GLSurface>& surface) override;
-  virtual void ProduceFrontBuffer(const Mailbox& mailbox) override;
-  virtual bool ResizeOffscreenFrameBuffer(const gfx::Size& size) override;
+  bool Initialize(const scoped_refptr<gfx::GLSurface>& surface,
+                  const scoped_refptr<gfx::GLContext>& context,
+                  bool offscreen,
+                  const gfx::Size& size,
+                  const DisallowedFeatures& disallowed_features,
+                  const std::vector<int32>& attribs) override;
+  void Destroy(bool have_context) override;
+  void SetSurface(const scoped_refptr<gfx::GLSurface>& surface) override;
+  void ProduceFrontBuffer(const Mailbox& mailbox) override;
+  bool ResizeOffscreenFrameBuffer(const gfx::Size& size) override;
   void UpdateParentTextureInfo();
-  virtual bool MakeCurrent() override;
-  virtual GLES2Util* GetGLES2Util() override { return &util_; }
-  virtual gfx::GLContext* GetGLContext() override { return context_.get(); }
-  virtual ContextGroup* GetContextGroup() override { return group_.get(); }
-  virtual Capabilities GetCapabilities() override;
-  virtual void RestoreState(const ContextState* prev_state) override;
-
-  virtual void RestoreActiveTexture() const override {
-    state_.RestoreActiveTexture();
-  }
-  virtual void RestoreAllTextureUnitBindings(
+  bool MakeCurrent() override;
+  GLES2Util* GetGLES2Util() override { return &util_; }
+  gfx::GLContext* GetGLContext() override { return context_.get(); }
+  ContextGroup* GetContextGroup() override { return group_.get(); }
+  Capabilities GetCapabilities() override;
+  void RestoreState(const ContextState* prev_state) override;
+
+  void RestoreActiveTexture() const override { state_.RestoreActiveTexture(); }
+  void RestoreAllTextureUnitBindings(
       const ContextState* prev_state) const override {
     state_.RestoreAllTextureUnitBindings(prev_state);
   }
-  virtual void RestoreActiveTextureUnitBinding(
-      unsigned int target) const override {
+  void RestoreActiveTextureUnitBinding(unsigned int target) const override {
     state_.RestoreActiveTextureUnitBinding(target);
   }
-  virtual void RestoreBufferBindings() const override {
+  void RestoreBufferBindings() const override {
     state_.RestoreBufferBindings();
   }
-  virtual void RestoreGlobalState() const override {
-    state_.RestoreGlobalState(NULL);
-  }
-  virtual void RestoreProgramBindings() const override {
+  void RestoreGlobalState() const override { state_.RestoreGlobalState(NULL); }
+  void RestoreProgramBindings() const override {
     state_.RestoreProgramBindings();
   }
-  virtual void RestoreTextureUnitBindings(unsigned unit) const override {
+  void RestoreTextureUnitBindings(unsigned unit) const override {
     state_.RestoreTextureUnitBindings(unit, NULL);
   }
-  virtual void RestoreFramebufferBindings() const override;
-  virtual void RestoreRenderbufferBindings() override;
-  virtual void RestoreTextureState(unsigned service_id) const override;
+  void RestoreFramebufferBindings() const override;
+  void RestoreRenderbufferBindings() override;
+  void RestoreTextureState(unsigned service_id) const override;
 
-  virtual void ClearAllAttributes() const override;
-  virtual void RestoreAllAttributes() const override;
+  void ClearAllAttributes() const override;
+  void RestoreAllAttributes() const override;
 
-  virtual QueryManager* GetQueryManager() override {
-    return query_manager_.get();
-  }
-  virtual VertexArrayManager* GetVertexArrayManager() override {
+  QueryManager* GetQueryManager() override { return query_manager_.get(); }
+  VertexArrayManager* GetVertexArrayManager() override {
     return vertex_array_manager_.get();
   }
-  virtual ImageManager* GetImageManager() override {
-    return image_manager_.get();
-  }
-  virtual bool ProcessPendingQueries() override;
-  virtual bool HasMoreIdleWork() override;
-  virtual void PerformIdleWork() override;
+  ImageManager* GetImageManager() override { return image_manager_.get(); }
+  bool ProcessPendingQueries() override;
+  bool HasMoreIdleWork() override;
+  void PerformIdleWork() override;
 
-  virtual void WaitForReadPixels(base::Closure callback) override;
+  void WaitForReadPixels(base::Closure callback) override;
 
-  virtual void SetResizeCallback(
+  void SetResizeCallback(
       const base::Callback<void(gfx::Size, float)>& callback) override;
 
-  virtual Logger* GetLogger() override;
+  Logger* GetLogger() override;
 
-  virtual void BeginDecoding() override;
-  virtual void EndDecoding() override;
+  void BeginDecoding() override;
+  void EndDecoding() override;
 
-  virtual ErrorState* GetErrorState() override;
-  virtual const ContextState* GetContextState() override { return &state_; }
+  ErrorState* GetErrorState() override;
+  const ContextState* GetContextState() override { return &state_; }
 
-  virtual void SetShaderCacheCallback(
-      const ShaderCacheCallback& callback) override;
-  virtual void SetWaitSyncPointCallback(
-      const WaitSyncPointCallback& callback) override;
+  void SetShaderCacheCallback(const ShaderCacheCallback& callback) override;
+  void SetWaitSyncPointCallback(const WaitSyncPointCallback& callback) override;
 
-  virtual AsyncPixelTransferManager*
-      GetAsyncPixelTransferManager() override;
-  virtual void ResetAsyncPixelTransferManagerForTest() override;
-  virtual void SetAsyncPixelTransferManagerForTest(
+  AsyncPixelTransferManager* GetAsyncPixelTransferManager() override;
+  void ResetAsyncPixelTransferManagerForTest() override;
+  void SetAsyncPixelTransferManagerForTest(
       AsyncPixelTransferManager* manager) override;
-  virtual void SetIgnoreCachedStateForTest(bool ignore) override;
+  void SetIgnoreCachedStateForTest(bool ignore) override;
   void ProcessFinishedAsyncTransfers();
 
-  virtual bool GetServiceTextureId(uint32 client_texture_id,
-                                   uint32* service_texture_id) override;
+  bool GetServiceTextureId(uint32 client_texture_id,
+                           uint32* service_texture_id) override;
 
-  virtual uint32 GetTextureUploadCount() override;
-  virtual base::TimeDelta GetTotalTextureUploadTime() override;
-  virtual base::TimeDelta GetTotalProcessingCommandsTime() override;
-  virtual void AddProcessingCommandsTime(base::TimeDelta) override;
+  uint32 GetTextureUploadCount() override;
+  base::TimeDelta GetTotalTextureUploadTime() override;
+  base::TimeDelta GetTotalProcessingCommandsTime() override;
+  void AddProcessingCommandsTime(base::TimeDelta) override;
 
   // Restores the current state to the user's settings.
   void RestoreCurrentFramebufferBindings();
@@ -690,14 +676,13 @@ class GLES2DecoderImpl : public GLES2Decoder,
   bool BoundFramebufferHasDepthAttachment();
   bool BoundFramebufferHasStencilAttachment();
 
-  virtual error::ContextLostReason GetContextLostReason() override;
+  error::ContextLostReason GetContextLostReason() override;
 
   // Overridden from FramebufferManager::TextureDetachObserver:
-  virtual void OnTextureRefDetachedFromFramebuffer(
-      TextureRef* texture) override;
+  void OnTextureRefDetachedFromFramebuffer(TextureRef* texture) override;
 
   // Overriden from ErrorStateClient.
-  virtual void OnOutOfMemoryError() override;
+  void OnOutOfMemoryError() override;
 
   // Ensure Renderbuffer corresponding to last DoBindRenderbuffer() is bound.
   void EnsureRenderbufferBound();
@@ -1155,16 +1140,16 @@ class GLES2DecoderImpl : public GLES2Decoder,
   void ClearUnclearedAttachments(GLenum target, Framebuffer* framebuffer);
 
   // overridden from GLES2Decoder
-  virtual bool ClearLevel(unsigned service_id,
-                          unsigned bind_target,
-                          unsigned target,
-                          int level,
-                          unsigned internal_format,
-                          unsigned format,
-                          unsigned type,
-                          int width,
-                          int height,
-                          bool is_texture_immutable) override;
+  bool ClearLevel(unsigned service_id,
+                  unsigned bind_target,
+                  unsigned target,
+                  int level,
+                  unsigned internal_format,
+                  unsigned format,
+                  unsigned type,
+                  int width,
+                  int height,
+                  bool is_texture_immutable) override;
 
   // Restore all GL state that affects clearing.
   void RestoreClearState();
@@ -1577,9 +1562,9 @@ class GLES2DecoderImpl : public GLES2Decoder,
       void** result, GLenum* result_type);
 
   void MaybeExitOnContextLost();
-  virtual bool WasContextLost() override;
-  virtual bool WasContextLostByRobustnessExtension() override;
-  virtual void LoseContext(uint32 reset_status) override;
+  bool WasContextLost() override;
+  bool WasContextLostByRobustnessExtension() override;
+  void LoseContext(uint32 reset_status) override;
 
 #if defined(OS_MACOSX)
   void ReleaseIOSurfaceForTexture(GLuint texture_id);
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.h b/gpu/command_buffer/service/gles2_cmd_decoder.h
index 5c94b93..8d72335 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.h
@@ -68,7 +68,7 @@ class GPU_EXPORT GLES2Decoder : public base::SupportsWeakPtr<GLES2Decoder>,
   // Creates a decoder.
   static GLES2Decoder* Create(ContextGroup* group);
 
-  virtual ~GLES2Decoder();
+  ~GLES2Decoder() override;
 
   bool initialized() const {
     return initialized_;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
index d510946..1e7db3f 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
@@ -554,24 +554,23 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
    public:
     MockCommandBufferEngine();
 
-    virtual ~MockCommandBufferEngine();
+    ~MockCommandBufferEngine() override;
 
-    virtual scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id)
-        override;
+    scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id) override;
 
     void ClearSharedMemory() {
       memset(valid_buffer_->memory(), kInitialMemoryValue, kSharedBufferSize);
     }
 
-    virtual void set_token(int32 token) override;
+    void set_token(int32 token) override;
 
-    virtual bool SetGetBuffer(int32 /* transfer_buffer_id */) override;
+    bool SetGetBuffer(int32 /* transfer_buffer_id */) override;
 
     // Overridden from CommandBufferEngine.
-    virtual bool SetGetOffset(int32 offset) override;
+    bool SetGetOffset(int32 offset) override;
 
     // Overridden from CommandBufferEngine.
-    virtual int32 GetGetOffset() override;
+    int32 GetGetOffset() override;
 
    private:
     scoped_refptr<gpu::Buffer> valid_buffer_;
diff --git a/gpu/command_buffer/service/gpu_scheduler.h b/gpu/command_buffer/service/gpu_scheduler.h
index fed0ce4..5e47d4a 100644
--- a/gpu/command_buffer/service/gpu_scheduler.h
+++ b/gpu/command_buffer/service/gpu_scheduler.h
@@ -56,7 +56,7 @@ class GPU_EXPORT GpuScheduler
                AsyncAPIInterface* handler,
                gles2::GLES2Decoder* decoder);
 
-  virtual ~GpuScheduler();
+  ~GpuScheduler() override;
 
   void PutChanged();
 
@@ -83,11 +83,11 @@ class GPU_EXPORT GpuScheduler
   void SetSchedulingChangedCallback(const SchedulingChangedCallback& callback);
 
   // Implementation of CommandBufferEngine.
-  virtual scoped_refptr<Buffer> GetSharedMemoryBuffer(int32 shm_id) override;
-  virtual void set_token(int32 token) override;
-  virtual bool SetGetBuffer(int32 transfer_buffer_id) override;
-  virtual bool SetGetOffset(int32 offset) override;
-  virtual int32 GetGetOffset() override;
+  scoped_refptr<Buffer> GetSharedMemoryBuffer(int32 shm_id) override;
+  void set_token(int32 token) override;
+  bool SetGetBuffer(int32 transfer_buffer_id) override;
+  bool SetGetOffset(int32 offset) override;
+  int32 GetGetOffset() override;
 
   void SetCommandProcessedCallback(const base::Closure& callback);
 
diff --git a/gpu/command_buffer/service/gpu_state_tracer.cc b/gpu/command_buffer/service/gpu_state_tracer.cc
index 5311e9c..51b0eba 100644
--- a/gpu/command_buffer/service/gpu_state_tracer.cc
+++ b/gpu/command_buffer/service/gpu_state_tracer.cc
@@ -24,11 +24,11 @@ class Snapshot : public base::debug::ConvertableToTraceFormat {
   bool SaveScreenshot(const gfx::Size& size);
 
   // base::debug::ConvertableToTraceFormat implementation.
-  virtual void AppendAsTraceFormat(std::string* out) const override;
+  void AppendAsTraceFormat(std::string* out) const override;
 
  private:
   explicit Snapshot(const ContextState* state);
-  virtual ~Snapshot() {}
+  ~Snapshot() override {}
 
   const ContextState* state_;
 
diff --git a/gpu/command_buffer/service/gpu_tracer.h b/gpu/command_buffer/service/gpu_tracer.h
index 8099230..2e81b4e 100644
--- a/gpu/command_buffer/service/gpu_tracer.h
+++ b/gpu/command_buffer/service/gpu_tracer.h
@@ -115,14 +115,14 @@ class Outputter : public base::RefCounted<Outputter> {
 class TraceOutputter : public Outputter {
  public:
   static scoped_refptr<TraceOutputter> Create(const std::string& name);
-  virtual void Trace(const std::string& name,
-                     int64 start_time,
-                     int64 end_time) override;
+  void Trace(const std::string& name,
+             int64 start_time,
+             int64 end_time) override;
 
  protected:
   friend class base::RefCounted<Outputter>;
   explicit TraceOutputter(const std::string& name);
-  virtual ~TraceOutputter();
+  ~TraceOutputter() override;
 
   base::Thread named_thread_;
   uint64 local_trace_id_;
diff --git a/gpu/command_buffer/service/gpu_tracer_unittest.cc b/gpu/command_buffer/service/gpu_tracer_unittest.cc
index 6be4d5b..fe353c3 100644
--- a/gpu/command_buffer/service/gpu_tracer_unittest.cc
+++ b/gpu/command_buffer/service/gpu_tracer_unittest.cc
@@ -207,16 +207,12 @@ class BaseGpuTracerTest : public GpuServiceTest {
 
 class GpuARBTimerTracerTest : public BaseGpuTracerTest {
  protected:
-  virtual GpuTracerType GetTracerType() override {
-    return kTracerTypeARBTimer;
-  }
+  GpuTracerType GetTracerType() override { return kTracerTypeARBTimer; }
 };
 
 class GpuDisjointTimerTracerTest : public BaseGpuTracerTest {
  protected:
-  virtual GpuTracerType GetTracerType() override {
-    return kTracerTypeDisjointTimer;
-  }
+  GpuTracerType GetTracerType() override { return kTracerTypeDisjointTimer; }
 };
 
 TEST_F(GpuARBTimerTracerTest, GPUTrace) {
diff --git a/gpu/command_buffer/service/in_process_command_buffer.cc b/gpu/command_buffer/service/in_process_command_buffer.cc
index 310fced..33e5a2c 100644
--- a/gpu/command_buffer/service/in_process_command_buffer.cc
+++ b/gpu/command_buffer/service/in_process_command_buffer.cc
@@ -62,21 +62,21 @@ class GpuInProcessThread
  public:
   GpuInProcessThread();
 
-  virtual void AddRef() const override {
+  void AddRef() const override {
     base::RefCountedThreadSafe<GpuInProcessThread>::AddRef();
   }
-  virtual void Release() const override {
+  void Release() const override {
     base::RefCountedThreadSafe<GpuInProcessThread>::Release();
   }
 
-  virtual void ScheduleTask(const base::Closure& task) override;
-  virtual void ScheduleIdleWork(const base::Closure& callback) override;
-  virtual bool UseVirtualizedGLContexts() override { return false; }
-  virtual scoped_refptr<gles2::ShaderTranslatorCache> shader_translator_cache()
+  void ScheduleTask(const base::Closure& task) override;
+  void ScheduleIdleWork(const base::Closure& callback) override;
+  bool UseVirtualizedGLContexts() override { return false; }
+  scoped_refptr<gles2::ShaderTranslatorCache> shader_translator_cache()
       override;
 
  private:
-  virtual ~GpuInProcessThread();
+  ~GpuInProcessThread() override;
   friend class base::RefCountedThreadSafe<GpuInProcessThread>;
 
   scoped_refptr<gpu::gles2::ShaderTranslatorCache> shader_translator_cache_;
diff --git a/gpu/command_buffer/service/in_process_command_buffer.h b/gpu/command_buffer/service/in_process_command_buffer.h
index 65cf1ec..ec06ecd 100644
--- a/gpu/command_buffer/service/in_process_command_buffer.h
+++ b/gpu/command_buffer/service/in_process_command_buffer.h
@@ -64,7 +64,7 @@ class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
  public:
   class Service;
   explicit InProcessCommandBuffer(const scoped_refptr<Service>& service);
-  virtual ~InProcessCommandBuffer();
+  ~InProcessCommandBuffer() override;
 
   // If |surface| is not NULL, use it directly; in this case, the command
   // buffer gpu thread must be the same as the client thread. Otherwise create
@@ -80,38 +80,37 @@ class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
   void Destroy();
 
   // CommandBuffer implementation:
-  virtual bool Initialize() override;
-  virtual State GetLastState() override;
-  virtual int32 GetLastToken() override;
-  virtual void Flush(int32 put_offset) override;
-  virtual void WaitForTokenInRange(int32 start, int32 end) override;
-  virtual void WaitForGetOffsetInRange(int32 start, int32 end) override;
-  virtual void SetGetBuffer(int32 shm_id) override;
-  virtual scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size,
-                                                          int32* id) override;
-  virtual void DestroyTransferBuffer(int32 id) override;
-  virtual gpu::error::Error GetLastError() override;
+  bool Initialize() override;
+  State GetLastState() override;
+  int32 GetLastToken() override;
+  void Flush(int32 put_offset) override;
+  void WaitForTokenInRange(int32 start, int32 end) override;
+  void WaitForGetOffsetInRange(int32 start, int32 end) override;
+  void SetGetBuffer(int32 shm_id) override;
+  scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size,
+                                                  int32* id) override;
+  void DestroyTransferBuffer(int32 id) override;
+  gpu::error::Error GetLastError() override;
 
   // GpuControl implementation:
-  virtual gpu::Capabilities GetCapabilities() override;
-  virtual int32 CreateImage(ClientBuffer buffer,
-                            size_t width,
-                            size_t height,
-                            unsigned internalformat) override;
-  virtual void DestroyImage(int32 id) override;
-  virtual int32 CreateGpuMemoryBufferImage(size_t width,
-                                           size_t height,
-                                           unsigned internalformat,
-                                           unsigned usage) override;
-  virtual uint32 InsertSyncPoint() override;
-  virtual uint32 InsertFutureSyncPoint() override;
-  virtual void RetireSyncPoint(uint32 sync_point) override;
-  virtual void SignalSyncPoint(uint32 sync_point,
-                               const base::Closure& callback) override;
-  virtual void SignalQuery(uint32 query_id,
-                           const base::Closure& callback) override;
-  virtual void SetSurfaceVisible(bool visible) override;
-  virtual uint32 CreateStreamTexture(uint32 texture_id) override;
+  gpu::Capabilities GetCapabilities() override;
+  int32 CreateImage(ClientBuffer buffer,
+                    size_t width,
+                    size_t height,
+                    unsigned internalformat) override;
+  void DestroyImage(int32 id) override;
+  int32 CreateGpuMemoryBufferImage(size_t width,
+                                   size_t height,
+                                   unsigned internalformat,
+                                   unsigned usage) override;
+  uint32 InsertSyncPoint() override;
+  uint32 InsertFutureSyncPoint() override;
+  void RetireSyncPoint(uint32 sync_point) override;
+  void SignalSyncPoint(uint32 sync_point,
+                       const base::Closure& callback) override;
+  void SignalQuery(uint32 query_id, const base::Closure& callback) override;
+  void SetSurfaceVisible(bool visible) override;
+  uint32 CreateStreamTexture(uint32 texture_id) override;
 
   // The serializer interface to the GPU service (i.e. thread).
   class Service {
diff --git a/gpu/command_buffer/service/memory_program_cache.h b/gpu/command_buffer/service/memory_program_cache.h
index 804547ea..7560d01 100644
--- a/gpu/command_buffer/service/memory_program_cache.h
+++ b/gpu/command_buffer/service/memory_program_cache.h
@@ -24,9 +24,9 @@ class GPU_EXPORT MemoryProgramCache : public ProgramCache {
  public:
   MemoryProgramCache();
   explicit MemoryProgramCache(const size_t max_cache_size_bytes);
-  virtual ~MemoryProgramCache();
+  ~MemoryProgramCache() override;
 
-  virtual ProgramLoadResult LoadLinkedProgram(
+  ProgramLoadResult LoadLinkedProgram(
       GLuint program,
       Shader* shader_a,
       const ShaderTranslatorInterface* translator_a,
@@ -34,19 +34,18 @@ class GPU_EXPORT MemoryProgramCache : public ProgramCache {
       const ShaderTranslatorInterface* translator_b,
       const LocationMap* bind_attrib_location_map,
       const ShaderCacheCallback& shader_callback) override;
-  virtual void SaveLinkedProgram(
-      GLuint program,
-      const Shader* shader_a,
-      const ShaderTranslatorInterface* translator_a,
-      const Shader* shader_b,
-      const ShaderTranslatorInterface* translator_b,
-      const LocationMap* bind_attrib_location_map,
-      const ShaderCacheCallback& shader_callback) override;
+  void SaveLinkedProgram(GLuint program,
+                         const Shader* shader_a,
+                         const ShaderTranslatorInterface* translator_a,
+                         const Shader* shader_b,
+                         const ShaderTranslatorInterface* translator_b,
+                         const LocationMap* bind_attrib_location_map,
+                         const ShaderCacheCallback& shader_callback) override;
 
-  virtual void LoadProgram(const std::string& program) override;
+  void LoadProgram(const std::string& program) override;
 
  private:
-  virtual void ClearBackend() override;
+  void ClearBackend() override;
 
   class ProgramCacheValue : public base::RefCounted<ProgramCacheValue> {
    public:
diff --git a/gpu/command_buffer/service/program_cache_unittest.cc b/gpu/command_buffer/service/program_cache_unittest.cc
index 37597d3..525fea1 100644
--- a/gpu/command_buffer/service/program_cache_unittest.cc
+++ b/gpu/command_buffer/service/program_cache_unittest.cc
@@ -15,7 +15,7 @@ namespace gles2 {
 
 class NoBackendProgramCache : public ProgramCache {
  public:
-  virtual ProgramLoadResult LoadLinkedProgram(
+  ProgramLoadResult LoadLinkedProgram(
       GLuint /* program */,
       Shader* /* shader_a */,
       const ShaderTranslatorInterface* /* translator_a */,
@@ -25,18 +25,17 @@ class NoBackendProgramCache : public ProgramCache {
       const ShaderCacheCallback& /* callback */) override {
     return PROGRAM_LOAD_SUCCESS;
   }
-  virtual void SaveLinkedProgram(
-      GLuint /* program */,
-      const Shader* /* shader_a */,
-      const ShaderTranslatorInterface* /* translator_b */,
-      const Shader* /* shader_b */,
-      const ShaderTranslatorInterface* /* translator_b */,
-      const LocationMap* /* bind_attrib_location_map */,
-      const ShaderCacheCallback& /* callback */) override { }
+  void SaveLinkedProgram(GLuint /* program */,
+                         const Shader* /* shader_a */,
+                         const ShaderTranslatorInterface* /* translator_b */,
+                         const Shader* /* shader_b */,
+                         const ShaderTranslatorInterface* /* translator_b */,
+                         const LocationMap* /* bind_attrib_location_map */,
+                         const ShaderCacheCallback& /* callback */) override {}
 
-  virtual void LoadProgram(const std::string& /* program */) override {}
+  void LoadProgram(const std::string& /* program */) override {}
 
-  virtual void ClearBackend() override {}
+  void ClearBackend() override {}
 
   void SaySuccessfullyCached(const std::string& shader1,
                              const ShaderTranslatorInterface* translator_1,
diff --git a/gpu/command_buffer/service/query_manager.cc b/gpu/command_buffer/service/query_manager.cc
index fdc7d0a..5f518eca 100644
--- a/gpu/command_buffer/service/query_manager.cc
+++ b/gpu/command_buffer/service/query_manager.cc
@@ -34,7 +34,7 @@ class AsyncPixelTransferCompletionObserverImpl
     cancelled_ = true;
   }
 
-  virtual void DidComplete(const AsyncMemoryParams& mem_params) override {
+  void DidComplete(const AsyncMemoryParams& mem_params) override {
     base::AutoLock locked(lock_);
     if (!cancelled_) {
       DCHECK(mem_params.buffer().get());
@@ -45,7 +45,7 @@ class AsyncPixelTransferCompletionObserverImpl
   }
 
  private:
-  virtual ~AsyncPixelTransferCompletionObserverImpl() {}
+  ~AsyncPixelTransferCompletionObserverImpl() override {}
 
   base::subtle::Atomic32 submit_count_;
 
@@ -62,13 +62,13 @@ class AsyncPixelTransfersCompletedQuery
   AsyncPixelTransfersCompletedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
-  virtual bool Begin() override;
-  virtual bool End(base::subtle::Atomic32 submit_count) override;
-  virtual bool Process() override;
-  virtual void Destroy(bool have_context) override;
+  bool Begin() override;
+  bool End(base::subtle::Atomic32 submit_count) override;
+  bool Process() override;
+  void Destroy(bool have_context) override;
 
  protected:
-  virtual ~AsyncPixelTransfersCompletedQuery();
+  ~AsyncPixelTransfersCompletedQuery() override;
 
   scoped_refptr<AsyncPixelTransferCompletionObserverImpl> observer_;
 };
@@ -139,13 +139,13 @@ class AllSamplesPassedQuery : public QueryManager::Query {
   AllSamplesPassedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset,
       GLuint service_id);
-  virtual bool Begin() override;
-  virtual bool End(base::subtle::Atomic32 submit_count) override;
-  virtual bool Process() override;
-  virtual void Destroy(bool have_context) override;
+  bool Begin() override;
+  bool End(base::subtle::Atomic32 submit_count) override;
+  bool Process() override;
+  void Destroy(bool have_context) override;
 
  protected:
-  virtual ~AllSamplesPassedQuery();
+  ~AllSamplesPassedQuery() override;
 
  private:
   // Service side query id.
@@ -198,13 +198,13 @@ class CommandsIssuedQuery : public QueryManager::Query {
   CommandsIssuedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
-  virtual bool Begin() override;
-  virtual bool End(base::subtle::Atomic32 submit_count) override;
-  virtual bool Process() override;
-  virtual void Destroy(bool have_context) override;
+  bool Begin() override;
+  bool End(base::subtle::Atomic32 submit_count) override;
+  bool Process() override;
+  void Destroy(bool have_context) override;
 
  protected:
-  virtual ~CommandsIssuedQuery();
+  ~CommandsIssuedQuery() override;
 
  private:
   base::TimeTicks begin_time_;
@@ -245,13 +245,13 @@ class CommandLatencyQuery : public QueryManager::Query {
   CommandLatencyQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
-  virtual bool Begin() override;
-  virtual bool End(base::subtle::Atomic32 submit_count) override;
-  virtual bool Process() override;
-  virtual void Destroy(bool have_context) override;
+  bool Begin() override;
+  bool End(base::subtle::Atomic32 submit_count) override;
+  bool Process() override;
+  void Destroy(bool have_context) override;
 
  protected:
-  virtual ~CommandLatencyQuery();
+  ~CommandLatencyQuery() override;
 };
 
 CommandLatencyQuery::CommandLatencyQuery(
@@ -291,14 +291,14 @@ class AsyncReadPixelsCompletedQuery
   AsyncReadPixelsCompletedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
-  virtual bool Begin() override;
-  virtual bool End(base::subtle::Atomic32 submit_count) override;
-  virtual bool Process() override;
-  virtual void Destroy(bool have_context) override;
+  bool Begin() override;
+  bool End(base::subtle::Atomic32 submit_count) override;
+  bool Process() override;
+  void Destroy(bool have_context) override;
 
  protected:
   void Complete();
-  virtual ~AsyncReadPixelsCompletedQuery();
+  ~AsyncReadPixelsCompletedQuery() override;
 
  private:
   bool completed_;
@@ -351,13 +351,13 @@ class GetErrorQuery : public QueryManager::Query {
   GetErrorQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
-  virtual bool Begin() override;
-  virtual bool End(base::subtle::Atomic32 submit_count) override;
-  virtual bool Process() override;
-  virtual void Destroy(bool have_context) override;
+  bool Begin() override;
+  bool End(base::subtle::Atomic32 submit_count) override;
+  bool Process() override;
+  void Destroy(bool have_context) override;
 
  protected:
-  virtual ~GetErrorQuery();
+  ~GetErrorQuery() override;
 
  private:
 };
@@ -398,13 +398,13 @@ class CommandsCompletedQuery : public QueryManager::Query {
                          uint32 shm_offset);
 
   // Overridden from QueryManager::Query:
-  virtual bool Begin() override;
-  virtual bool End(base::subtle::Atomic32 submit_count) override;
-  virtual bool Process() override;
-  virtual void Destroy(bool have_context) override;
+  bool Begin() override;
+  bool End(base::subtle::Atomic32 submit_count) override;
+  bool Process() override;
+  void Destroy(bool have_context) override;
 
  protected:
-  virtual ~CommandsCompletedQuery();
+  ~CommandsCompletedQuery() override;
 
  private:
   scoped_ptr<gfx::GLFence> fence_;
diff --git a/gpu/command_buffer/service/query_manager_unittest.cc b/gpu/command_buffer/service/query_manager_unittest.cc
index f6335e8..b4f1653 100644
--- a/gpu/command_buffer/service/query_manager_unittest.cc
+++ b/gpu/command_buffer/service/query_manager_unittest.cc
@@ -96,11 +96,9 @@ class QueryManagerTest : public GpuServiceTest {
       ClearSharedMemory();
     }
 
-    virtual ~MockCommandBufferEngine() {
-    }
+    ~MockCommandBufferEngine() override {}
 
-    virtual scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id)
-        override {
+    scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id) override {
       return shm_id == kSharedMemoryId ? valid_buffer_ : invalid_buffer_;
     }
 
@@ -108,23 +106,21 @@ class QueryManagerTest : public GpuServiceTest {
       memset(data_, kInitialMemoryValue, kSharedBufferSize);
     }
 
-    virtual void set_token(int32 token) override {
-      DCHECK(false);
-    }
+    void set_token(int32 token) override { DCHECK(false); }
 
-    virtual bool SetGetBuffer(int32 /* transfer_buffer_id */) override {
+    bool SetGetBuffer(int32 /* transfer_buffer_id */) override {
       DCHECK(false);
       return false;
     }
 
     // Overridden from CommandBufferEngine.
-    virtual bool SetGetOffset(int32 offset) override {
+    bool SetGetOffset(int32 offset) override {
       DCHECK(false);
       return false;
     }
 
     // Overridden from CommandBufferEngine.
-    virtual int32 GetGetOffset() override {
+    int32 GetGetOffset() override {
       DCHECK(false);
       return 0;
     }
diff --git a/gpu/command_buffer/service/shader_translator.h b/gpu/command_buffer/service/shader_translator.h
index ff9d741..6075896 100644
--- a/gpu/command_buffer/service/shader_translator.h
+++ b/gpu/command_buffer/service/shader_translator.h
@@ -83,24 +83,22 @@ class GPU_EXPORT ShaderTranslator
   ShaderTranslator();
 
   // Overridden from ShaderTranslatorInterface.
-  virtual bool Init(
-      sh::GLenum shader_type,
-      ShShaderSpec shader_spec,
-      const ShBuiltInResources* resources,
-      GlslImplementationType glsl_implementation_type,
-      ShCompileOptions driver_bug_workarounds) override;
+  bool Init(sh::GLenum shader_type,
+            ShShaderSpec shader_spec,
+            const ShBuiltInResources* resources,
+            GlslImplementationType glsl_implementation_type,
+            ShCompileOptions driver_bug_workarounds) override;
 
   // Overridden from ShaderTranslatorInterface.
-  virtual bool Translate(const std::string& shader_source,
-                         std::string* info_log,
-                         std::string* translated_source,
-                         AttributeMap* attrib_map,
-                         UniformMap* uniform_map,
-                         VaryingMap* varying_map,
-                         NameMap* name_map) const override;
+  bool Translate(const std::string& shader_source,
+                 std::string* info_log,
+                 std::string* translated_source,
+                 AttributeMap* attrib_map,
+                 UniformMap* uniform_map,
+                 VaryingMap* varying_map,
+                 NameMap* name_map) const override;
 
-  virtual std::string GetStringForOptionsThatWouldAffectCompilation() const
-      override;
+  std::string GetStringForOptionsThatWouldAffectCompilation() const override;
 
   void AddDestructionObserver(DestructionObserver* observer);
   void RemoveDestructionObserver(DestructionObserver* observer);
@@ -108,7 +106,7 @@ class GPU_EXPORT ShaderTranslator
  private:
   friend class base::RefCounted<ShaderTranslator>;
 
-  virtual ~ShaderTranslator();
+  ~ShaderTranslator() override;
   int GetCompileOptions() const;
 
   ShHandle compiler_;
diff --git a/gpu/command_buffer/service/shader_translator_cache.h b/gpu/command_buffer/service/shader_translator_cache.h
index 02f5829..e804ef2 100644
--- a/gpu/command_buffer/service/shader_translator_cache.h
+++ b/gpu/command_buffer/service/shader_translator_cache.h
@@ -29,7 +29,7 @@ class GPU_EXPORT ShaderTranslatorCache
   ShaderTranslatorCache();
 
   // ShaderTranslator::DestructionObserver implementation
-  virtual void OnDestruct(ShaderTranslator* translator) override;
+  void OnDestruct(ShaderTranslator* translator) override;
 
   scoped_refptr<ShaderTranslator> GetTranslator(
       sh::GLenum shader_type,
@@ -41,7 +41,7 @@ class GPU_EXPORT ShaderTranslatorCache
 
  private:
   friend class base::RefCounted<ShaderTranslatorCache>;
-  virtual ~ShaderTranslatorCache();
+  ~ShaderTranslatorCache() override;
 
   // Parameters passed into ShaderTranslator::Init
   struct ShaderTranslatorInitParams {
diff --git a/gpu/command_buffer/service/texture_definition.cc b/gpu/command_buffer/service/texture_definition.cc
index 6255a1c..cf385d2 100644
--- a/gpu/command_buffer/service/texture_definition.cc
+++ b/gpu/command_buffer/service/texture_definition.cc
@@ -30,23 +30,23 @@ class GLImageSync : public gfx::GLImage {
                        const gfx::Size& size);
 
   // Implement GLImage.
-  virtual void Destroy(bool have_context) override;
-  virtual gfx::Size GetSize() override;
-  virtual bool BindTexImage(unsigned target) override;
-  virtual void ReleaseTexImage(unsigned target) override;
-  virtual bool CopyTexImage(unsigned target) override;
-  virtual void WillUseTexImage() override;
-  virtual void WillModifyTexImage() override;
-  virtual void DidModifyTexImage() override;
-  virtual void DidUseTexImage() override;
-  virtual bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
-                                    int z_order,
-                                    gfx::OverlayTransform transform,
-                                    const gfx::Rect& bounds_rect,
-                                    const gfx::RectF& crop_rect) override;
+  void Destroy(bool have_context) override;
+  gfx::Size GetSize() override;
+  bool BindTexImage(unsigned target) override;
+  void ReleaseTexImage(unsigned target) override;
+  bool CopyTexImage(unsigned target) override;
+  void WillUseTexImage() override;
+  void WillModifyTexImage() override;
+  void DidModifyTexImage() override;
+  void DidUseTexImage() override;
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                            int z_order,
+                            gfx::OverlayTransform transform,
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override;
 
  protected:
-  virtual ~GLImageSync();
+  ~GLImageSync() override;
 
  private:
   scoped_refptr<NativeImageBuffer> buffer_;
@@ -306,15 +306,15 @@ class NativeImageBufferStub : public NativeImageBuffer {
   NativeImageBufferStub() : NativeImageBuffer() {}
 
  private:
-  virtual ~NativeImageBufferStub() {}
-  virtual void AddClient(gfx::GLImage* client) override {}
-  virtual void RemoveClient(gfx::GLImage* client) override {}
-  virtual bool IsClient(gfx::GLImage* client) override { return true; }
-  virtual void BindToTexture(GLenum target) override {}
-  virtual void WillRead(gfx::GLImage* client) override {}
-  virtual void WillWrite(gfx::GLImage* client) override {}
-  virtual void DidRead(gfx::GLImage* client) override {}
-  virtual void DidWrite(gfx::GLImage* client) override {}
+  ~NativeImageBufferStub() override {}
+  void AddClient(gfx::GLImage* client) override {}
+  void RemoveClient(gfx::GLImage* client) override {}
+  bool IsClient(gfx::GLImage* client) override { return true; }
+  void BindToTexture(GLenum target) override {}
+  void WillRead(gfx::GLImage* client) override {}
+  void WillWrite(gfx::GLImage* client) override {}
+  void DidRead(gfx::GLImage* client) override {}
+  void DidWrite(gfx::GLImage* client) override {}
 
   DISALLOW_COPY_AND_ASSIGN(NativeImageBufferStub);
 };
diff --git a/gpu/command_buffer/service/texture_manager_unittest.cc b/gpu/command_buffer/service/texture_manager_unittest.cc
index 9604cb1..157138f 100644
--- a/gpu/command_buffer/service/texture_manager_unittest.cc
+++ b/gpu/command_buffer/service/texture_manager_unittest.cc
@@ -2167,16 +2167,14 @@ class CountingMemoryTracker : public MemoryTracker {
     current_size_[1] = 0;
   }
 
-  virtual void TrackMemoryAllocatedChange(size_t old_size,
-                                          size_t new_size,
-                                          Pool pool)  override {
+  void TrackMemoryAllocatedChange(size_t old_size,
+                                  size_t new_size,
+                                  Pool pool) override {
     DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_));
     current_size_[pool] += new_size - old_size;
   }
 
-  virtual bool EnsureGPUMemoryAvailable(size_t size_needed) override {
-    return true;
-  }
+  bool EnsureGPUMemoryAvailable(size_t size_needed) override { return true; }
 
   size_t GetSize(Pool pool) {
     DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_));
@@ -2184,7 +2182,7 @@ class CountingMemoryTracker : public MemoryTracker {
   }
 
  private:
-  virtual ~CountingMemoryTracker() {}
+  ~CountingMemoryTracker() override {}
 
   size_t current_size_[2];
   DISALLOW_COPY_AND_ASSIGN(CountingMemoryTracker);
diff --git a/gpu/command_buffer/service/transfer_buffer_manager.h b/gpu/command_buffer/service/transfer_buffer_manager.h
index 40cd168..f867790 100644
--- a/gpu/command_buffer/service/transfer_buffer_manager.h
+++ b/gpu/command_buffer/service/transfer_buffer_manager.h
@@ -32,14 +32,14 @@ class GPU_EXPORT TransferBufferManager
   TransferBufferManager();
 
   bool Initialize();
-  virtual bool RegisterTransferBuffer(int32 id,
-                                      scoped_ptr<BufferBacking> buffer_backing)
-      override;
-  virtual void DestroyTransferBuffer(int32 id) override;
-  virtual scoped_refptr<Buffer> GetTransferBuffer(int32 id) override;
+  bool RegisterTransferBuffer(
+      int32 id,
+      scoped_ptr<BufferBacking> buffer_backing) override;
+  void DestroyTransferBuffer(int32 id) override;
+  scoped_refptr<Buffer> GetTransferBuffer(int32 id) override;
 
  private:
-  virtual ~TransferBufferManager();
+  ~TransferBufferManager() override;
 
   typedef base::hash_map<int32, scoped_refptr<Buffer> > BufferMap;
   BufferMap registered_buffers_;
diff --git a/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc b/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
index 44d0840..563b6cb 100644
--- a/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
@@ -57,10 +57,10 @@ TEST_F(TransferBufferManagerTest, CanRegisterTransferBuffer) {
 
 class FakeBufferBacking : public BufferBacking {
  public:
-  virtual void* GetMemory() const override {
+  void* GetMemory() const override {
     return reinterpret_cast<void*>(0xBADF00D0);
   }
-  virtual size_t GetSize() const override { return 42; }
+  size_t GetSize() const override { return 42; }
   static scoped_ptr<BufferBacking> Make() {
     return scoped_ptr<BufferBacking>(new FakeBufferBacking);
   }