Standardize usage of virtual/override/final in content/

content/common/gpu/client/command_buffer_proxy_impl.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_
 #define CONTENT_COMMON_GPU_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_
 
 #include <map>
 #include <queue>
 #include <string>
@@ skipping 44 matching lines @@
     virtual void OnWillDeleteImpl() = 0;
 
    protected:
     virtual ~DeletionObserver() {}
   };
 
   typedef base::Callback<void(
       const std::string& msg, int id)> GpuConsoleMessageCallback;
 
   CommandBufferProxyImpl(GpuChannelHost* channel, int route_id);
-  virtual ~CommandBufferProxyImpl();
+  ~CommandBufferProxyImpl() override;
 
   // Sends an IPC message to create a GpuVideoDecodeAccelerator. Creates and
   // returns it as an owned pointer to a media::VideoDecodeAccelerator.  Returns
   // NULL on failure to create the GpuVideoDecodeAcceleratorHost.
   // Note that the GpuVideoDecodeAccelerator may still fail to be created in
   // the GPU process, even if this returns non-NULL. In this case the VDA client
   // is notified of an error later, after Initialize().
   scoped_ptr<media::VideoDecodeAccelerator> CreateVideoDecoder();
 
   // Sends an IPC message to create a GpuVideoEncodeAccelerator. Creates and
   // returns it as an owned pointer to a media::VideoEncodeAccelerator.  Returns
   // NULL on failure to create the GpuVideoEncodeAcceleratorHost.
   // Note that the GpuVideoEncodeAccelerator may still fail to be created in
   // the GPU process, even if this returns non-NULL. In this case the VEA client
   // is notified of an error later, after Initialize();
   scoped_ptr<media::VideoEncodeAccelerator> CreateVideoEncoder();
 
   // IPC::Listener implementation:
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
-  virtual void OnChannelError() override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+  void OnChannelError() 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 shm_id) override;
-  virtual scoped_refptr<gpu::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 shm_id) override;
+  scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size,
+                                                  int32* id) override;
+  void DestroyTransferBuffer(int32 id) override;
 
   // gpu::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_t InsertFutureSyncPoint() override;
-  virtual void RetireSyncPoint(uint32_t sync_point) override;
-  virtual void SignalSyncPoint(uint32 sync_point,
-                               const base::Closure& callback) override;
-  virtual void SignalQuery(uint32 query,
-                           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_t InsertFutureSyncPoint() override;
+  void RetireSyncPoint(uint32_t sync_point) override;
+  void SignalSyncPoint(uint32 sync_point,
+                       const base::Closure& callback) override;
+  void SignalQuery(uint32 query, const base::Closure& callback) override;
+  void SetSurfaceVisible(bool visible) override;
+  uint32 CreateStreamTexture(uint32 texture_id) override;
 
   int GetRouteID() const;
   bool ProduceFrontBuffer(const gpu::Mailbox& mailbox);
   void SetChannelErrorCallback(const base::Closure& callback);
 
   typedef base::Callback<void(const gpu::MemoryAllocation&)>
       MemoryAllocationChangedCallback;
   void SetMemoryAllocationChangedCallback(
       const MemoryAllocationChangedCallback& callback);
   void AddDeletionObserver(DeletionObserver* observer);
   void RemoveDeletionObserver(DeletionObserver* observer);
 
   bool EnsureBackbuffer();
 
   void SetOnConsoleMessageCallback(
       const GpuConsoleMessageCallback& callback);
 
   void SetLatencyInfo(const std::vector<ui::LatencyInfo>& latency_info);
   typedef base::Callback<void(const std::vector<ui::LatencyInfo>& latency_info)>
       SwapBuffersCompletionCallback;
   void SetSwapBuffersCompletionCallback(
       const SwapBuffersCompletionCallback& callback);
 
   // TODO(apatrick): this is a temporary optimization while skia is calling
   // ContentGLContext::MakeCurrent prior to every GL call. It saves returning 6
   // ints redundantly when only the error is needed for the
   // CommandBufferProxyImpl implementation.
-  virtual gpu::error::Error GetLastError() override;
+  gpu::error::Error GetLastError() override;
 
   GpuChannelHost* channel() const { return channel_; }
 
   base::SharedMemoryHandle GetSharedStateHandle() const {
     return shared_state_shm_->handle();
   }
 
  private:
   typedef std::map<int32, scoped_refptr<gpu::Buffer> > TransferBufferMap;
   typedef base::hash_map<uint32, base::Closure> SignalTaskMap;
@@ skipping 53 matching lines @@
   std::vector<ui::LatencyInfo> latency_info_;
 
   SwapBuffersCompletionCallback swap_buffers_completion_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CommandBufferProxyImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_