Standardize usage of virtual/override/final in net/

net/base/io_buffer.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 NET_BASE_IO_BUFFER_H_
 #define NET_BASE_IO_BUFFER_H_
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
@@ skipping 86 matching lines @@
  public:
   explicit IOBufferWithSize(int size);
 
   int size() const { return size_; }
 
  protected:
   // Purpose of this constructor is to give a subclass access to the base class
   // constructor IOBuffer(char*) thus allowing subclass to use underlying
   // memory it does not own.
   IOBufferWithSize(char* data, int size);
-  virtual ~IOBufferWithSize();
+  ~IOBufferWithSize() override;
 
   int size_;
 };
 
 // This is a read only IOBuffer.  The data is stored in a string and
 // the IOBuffer interface does not provide a proper way to modify it.
 class NET_EXPORT StringIOBuffer : public IOBuffer {
  public:
   explicit StringIOBuffer(const std::string& s);
   explicit StringIOBuffer(scoped_ptr<std::string> s);
 
   int size() const { return static_cast<int>(string_data_.size()); }
 
  private:
-  virtual ~StringIOBuffer();
+  ~StringIOBuffer() override;
 
   std::string string_data_;
 };
 
 // This version wraps an existing IOBuffer and provides convenient functions
 // to progressively read all the data.
 //
 // DrainableIOBuffer is useful when you have an IOBuffer that contains data
 // to be written progressively, and Write() function takes an IOBuffer rather
 // than char*. DrainableIOBuffer can be used as follows:
@@ skipping 22 matching lines @@
   // Returns the number of consumed bytes.
   int BytesConsumed() const;
 
   // Seeks to an arbitrary point in the buffer. The notion of bytes consumed
   // and remaining are updated appropriately.
   void SetOffset(int bytes);
 
   int size() const { return size_; }
 
  private:
-  virtual ~DrainableIOBuffer();
+  ~DrainableIOBuffer() override;
 
   scoped_refptr<IOBuffer> base_;
   int size_;
   int used_;
 };
 
 // This version provides a resizable buffer and a changeable offset.
 //
 // GrowableIOBuffer is useful when you read data progressively without
 // knowing the total size in advance. GrowableIOBuffer can be used as
@@ skipping 19 matching lines @@
   int capacity() { return capacity_; }
 
   // |offset| moves the |data_| pointer, allowing "seeking" in the data.
   void set_offset(int offset);
   int offset() { return offset_; }
 
   int RemainingCapacity();
   char* StartOfBuffer();
 
  private:
-  virtual ~GrowableIOBuffer();
+  ~GrowableIOBuffer() override;
 
   scoped_ptr<char, base::FreeDeleter> real_data_;
   int capacity_;
   int offset_;
 };
 
 // This versions allows a pickle to be used as the storage for a write-style
 // operation, avoiding an extra data copy.
 class NET_EXPORT PickledIOBuffer : public IOBuffer {
  public:
   PickledIOBuffer();
 
   Pickle* pickle() { return &pickle_; }
 
   // Signals that we are done writing to the pickle and we can use it for a
   // write-style IO operation.
   void Done();
 
  private:
-  virtual ~PickledIOBuffer();
+  ~PickledIOBuffer() override;
 
   Pickle pickle_;
 };
 
 // This class allows the creation of a temporary IOBuffer that doesn't really
 // own the underlying buffer. Please use this class only as a last resort.
 // A good example is the buffer for a synchronous operation, where we can be
 // sure that nobody is keeping an extra reference to this object so the lifetime
 // of the buffer can be completely managed by its intended owner.
 class NET_EXPORT WrappedIOBuffer : public IOBuffer {
  public:
   explicit WrappedIOBuffer(const char* data);
 
  protected:
-  virtual ~WrappedIOBuffer();
+  ~WrappedIOBuffer() override;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_IO_BUFFER_H_