Standardize usage of virtual/override/final in extensions/

extensions/browser/api/serial/serial_connection.cc

 // Copyright 2014 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 "extensions/browser/api/serial/serial_connection.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
@@ skipping 121 matching lines @@
   }
   return device::serial::STOP_BITS_NONE;
 }
 
 class SendBuffer : public device::ReadOnlyBuffer {
  public:
   SendBuffer(
       const std::string& data,
       const base::Callback<void(int, device::serial::SendError)>& callback)
       : data_(data), callback_(callback) {}
-  virtual ~SendBuffer() {}
-  virtual const char* GetData() override { return data_.c_str(); }
-  virtual uint32_t GetSize() override {
-    return static_cast<uint32_t>(data_.size());
-  }
-  virtual void Done(uint32_t bytes_read) override {
+  ~SendBuffer() override {}
+  const char* GetData() override { return data_.c_str(); }
+  uint32_t GetSize() override { return static_cast<uint32_t>(data_.size()); }
+  void Done(uint32_t bytes_read) override {
     callback_.Run(bytes_read, device::serial::SEND_ERROR_NONE);
   }
-  virtual void DoneWithError(uint32_t bytes_read, int32_t error) override {
+  void DoneWithError(uint32_t bytes_read, int32_t error) override {
     callback_.Run(bytes_read, static_cast<device::serial::SendError>(error));
   }
 
  private:
   const std::string data_;
   const base::Callback<void(int, device::serial::SendError)> callback_;
 };
 
 class ReceiveBuffer : public device::WritableBuffer {
  public:
   ReceiveBuffer(
       scoped_refptr<net::IOBuffer> buffer,
       uint32_t size,
       const base::Callback<void(int, device::serial::ReceiveError)>& callback)
       : buffer_(buffer), size_(size), callback_(callback) {}
-  virtual ~ReceiveBuffer() {}
-  virtual char* GetData() override { return buffer_->data(); }
-  virtual uint32_t GetSize() override { return size_; }
-  virtual void Done(uint32_t bytes_written) override {
+  ~ReceiveBuffer() override {}
+  char* GetData() override { return buffer_->data(); }
+  uint32_t GetSize() override { return size_; }
+  void Done(uint32_t bytes_written) override {
     callback_.Run(bytes_written, device::serial::RECEIVE_ERROR_NONE);
   }
-  virtual void DoneWithError(uint32_t bytes_written, int32_t error) override {
+  void DoneWithError(uint32_t bytes_written, int32_t error) override {
     callback_.Run(bytes_written,
                   static_cast<device::serial::ReceiveError>(error));
   }
 
  private:
   scoped_refptr<net::IOBuffer> buffer_;
   const uint32_t size_;
   const base::Callback<void(int, device::serial::ReceiveError)> callback_;
 };
 
@@ skipping 247 matching lines @@
   output->parity_bit = extensions::ConvertParityBitToMojo(input.parity_bit);
   output->stop_bits = extensions::ConvertStopBitsToMojo(input.stop_bits);
   if (input.cts_flow_control.get()) {
     output->has_cts_flow_control = true;
     output->cts_flow_control = *input.cts_flow_control;
   }
   return output.Pass();
 }
 
 }  // namespace mojo