Standardize usage of virtual/override/final in gpu/

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 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/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 493 matching lines @@
   scoped_ptr<gfx::GLFence> fence;
 };
 
 class AsyncUploadTokenCompletionObserver
     : public AsyncPixelTransferCompletionObserver {
  public:
   explicit AsyncUploadTokenCompletionObserver(uint32 async_upload_token)
       : 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);
     sync->SetAsyncUploadToken(async_upload_token_);
   }
 
  private:
-  virtual ~AsyncUploadTokenCompletionObserver() {
-  }
+  ~AsyncUploadTokenCompletionObserver() override {}
 
   uint32 async_upload_token_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncUploadTokenCompletionObserver);
 };
 
 // }  // anonymous namespace.
 
 // static
 const unsigned int GLES2Decoder::kDefaultStencilMask =
@@ skipping 17 matching lines @@
 
 void GLES2Decoder::EndDecoding() {}
 
 // This class implements GLES2Decoder so we don't have to expose all the GLES2
 // cmd stuff to outside this class.
 class GLES2DecoderImpl : public GLES2Decoder,
                          public FramebufferManager::TextureDetachObserver,
                          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,
                               const void* buffer,
                               int num_entries,
                               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;
+  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;
 
-  virtual void RestoreActiveTexture() const override {
-    state_.RestoreActiveTexture();
-  }
-  virtual void RestoreAllTextureUnitBindings(
+  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();
 
   // Sets DEPTH_TEST, STENCIL_TEST and color mask for the current framebuffer.
   void ApplyDirtyState();
 
   // These check the state of the currently bound framebuffer or the
   // backbuffer if no framebuffer is bound.
   // If all_draw_buffers is false, only check with COLOR_ATTACHMENT0, otherwise
   // check with all attached and enabled color attachments.
   bool BoundFramebufferHasColorAttachmentWithAlpha(bool all_draw_buffers);
   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();
 
   // Helpers to facilitate calling into compatible extensions.
   static void RenderbufferStorageMultisampleHelper(
       const FeatureInfo* feature_info,
       GLenum target,
       GLsizei samples,
       GLenum internal_format,
@@ skipping 437 matching lines @@
       GLuint client_id, const char* data, uint32 data_size);
 
   // Clear any textures used by the current program.
   bool ClearUnclearedTextures();
 
   // Clears any uncleared attachments attached to the given frame buffer.
   // Returns false if there was a generated GL error.
   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();
 
   // Remembers the state of some capabilities.
   // Returns: true if glEnable/glDisable should actually be called.
   bool SetCapabilityState(GLenum cap, bool enabled);
 
   // Check that the currently bound framebuffers are valid.
   // Generates GL error if not.
@@ skipping 392 matching lines @@
   // Validates the program and location for a glGetUniform call and returns
   // a SizeResult setup to receive the result. Returns true if glGetUniform
   // should be called.
   bool GetUniformSetup(
       GLuint program, GLint fake_location,
       uint32 shm_id, uint32 shm_offset,
       error::Error* error, GLint* real_location, GLuint* service_id,
       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);
 #endif
 
   bool ValidateCompressedTexDimensions(
       const char* function_name,
       GLint level, GLsizei width, GLsizei height, GLenum format);
   bool ValidateCompressedTexFuncData(
       const char* function_name,
@@ skipping 9650 matching lines @@
   }
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu