Standardize usage of virtual/override/final in gpu/

gpu/command_buffer/service/common_decoder_unittest.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/common_decoder.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
 
@@ skipping 33 matching lines @@
   EXPECT_EQ(0, memcmp(data, bucket.GetData(0, sizeof(data)), sizeof(data)));
   EXPECT_TRUE(bucket.SetData(data, 2, sizeof(data)));
   EXPECT_EQ(0, memcmp(data, bucket.GetData(2, sizeof(data)), sizeof(data)));
   EXPECT_FALSE(bucket.SetData(data, 0, sizeof(data) * 2));
   EXPECT_FALSE(bucket.SetData(data, 5, sizeof(data)));
 }
 
 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);
   }
 
   CommonDecoder::Bucket* GetBucket(uint32 id) const {
     return CommonDecoder::GetBucket(id);
   }
 };
 
 class MockCommandBufferEngine : public CommandBufferEngine {
  public:
   static const int32 kStartValidShmId = 1;
   static const int32 kValidShmId = 2;
   static const int32 kInvalidShmId = 3;
   static const size_t kBufferSize = 1024;
   static const int32 kValidOffset = kBufferSize / 2;
   static const int32 kInvalidOffset = kBufferSize;
 
   MockCommandBufferEngine()
       : CommandBufferEngine(),
         token_(),
         get_offset_(0) {
     scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
     shared_memory->CreateAndMapAnonymous(kBufferSize);
     buffer_ = MakeBufferFromSharedMemory(shared_memory.Pass(), kBufferSize);
   }
 
   // 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;
   }
 
   template <typename T>
   T GetSharedMemoryAs(uint32 offset) {
     DCHECK_LT(offset, kBufferSize);
     int8* buffer_memory = static_cast<int8*>(buffer_->memory());
     return reinterpret_cast<T>(&buffer_memory[offset]);
   }
 
   int32 GetSharedMemoryOffset(const void* memory) {
     int8* buffer_memory = static_cast<int8*>(buffer_->memory());
     ptrdiff_t offset = static_cast<const int8*>(memory) - &buffer_memory[0];
     DCHECK_GE(offset, 0);
     DCHECK_LT(static_cast<size_t>(offset), kBufferSize);
     return static_cast<int32>(offset);
   }
 
   // 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;
     }
     return false;
   }
 
   // Overridden from CommandBufferEngine.
-  virtual int32 GetGetOffset() override {
-    return get_offset_;
-  }
+  int32 GetGetOffset() override { return get_offset_; }
 
  private:
   bool IsValidSharedMemoryId(int32 shm_id) {
     return shm_id == kValidShmId || shm_id == kStartValidShmId;
   }
 
   scoped_refptr<gpu::Buffer> buffer_;
   int32 token_;
   int32 get_offset_;
 };
@@ skipping 354 matching lines @@
            MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 
   // Check that it fails if the size is invalid
   cmd.Init(kBucketId, 0, sizeof(kData) + 1,
            MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 }  // namespace gpu