Standardize usage of virtual/override/final in net/

net/disk_cache/simple/simple_entry_impl.h

 // Copyright (c) 2013 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_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_
 
 #include <queue>
 #include <string>
 
@@ skipping 62 matching lines @@
   int CreateEntry(Entry** entry, const CompletionCallback& callback);
 
   // Identical to Backend::Doom() except that it accepts a CompletionCallback.
   int DoomEntry(const CompletionCallback& callback);
 
   const std::string& key() const { return key_; }
   uint64 entry_hash() const { return entry_hash_; }
   void SetKey(const std::string& key);
 
   // From Entry:
-  virtual void Doom() override;
-  virtual void Close() override;
-  virtual std::string GetKey() const override;
-  virtual base::Time GetLastUsed() const override;
-  virtual base::Time GetLastModified() const override;
-  virtual int32 GetDataSize(int index) const override;
-  virtual int ReadData(int stream_index,
-                       int offset,
-                       net::IOBuffer* buf,
-                       int buf_len,
-                       const CompletionCallback& callback) override;
-  virtual int WriteData(int stream_index,
-                        int offset,
-                        net::IOBuffer* buf,
-                        int buf_len,
-                        const CompletionCallback& callback,
-                        bool truncate) override;
-  virtual int ReadSparseData(int64 offset,
-                             net::IOBuffer* buf,
-                             int buf_len,
-                             const CompletionCallback& callback) override;
-  virtual int WriteSparseData(int64 offset,
-                              net::IOBuffer* buf,
-                              int buf_len,
-                              const CompletionCallback& callback) override;
-  virtual int GetAvailableRange(int64 offset,
-                                int len,
-                                int64* start,
-                                const CompletionCallback& callback) override;
-  virtual bool CouldBeSparse() const override;
-  virtual void CancelSparseIO() override;
-  virtual int ReadyForSparseIO(const CompletionCallback& callback) override;
+  void Doom() override;
+  void Close() override;
+  std::string GetKey() const override;
+  base::Time GetLastUsed() const override;
+  base::Time GetLastModified() const override;
+  int32 GetDataSize(int index) const override;
+  int ReadData(int stream_index,
+               int offset,
+               net::IOBuffer* buf,
+               int buf_len,
+               const CompletionCallback& callback) override;
+  int WriteData(int stream_index,
+                int offset,
+                net::IOBuffer* buf,
+                int buf_len,
+                const CompletionCallback& callback,
+                bool truncate) override;
+  int ReadSparseData(int64 offset,
+                     net::IOBuffer* buf,
+                     int buf_len,
+                     const CompletionCallback& callback) override;
+  int WriteSparseData(int64 offset,
+                      net::IOBuffer* buf,
+                      int buf_len,
+                      const CompletionCallback& callback) override;
+  int GetAvailableRange(int64 offset,
+                        int len,
+                        int64* start,
+                        const CompletionCallback& callback) override;
+  bool CouldBeSparse() const override;
+  void CancelSparseIO() override;
+  int ReadyForSparseIO(const CompletionCallback& callback) override;
 
  private:
   class ScopedOperationRunner;
   friend class ScopedOperationRunner;
 
   enum State {
     // The state immediately after construction, but before |synchronous_entry_|
     // has been assigned. This is the state at construction, and is the only
     // legal state to destruct an entry in.
     STATE_UNINITIALIZED,
@@ skipping 12 matching lines @@
 
   // Used in histograms, please only add entries at the end.
   enum CheckCrcResult {
     CRC_CHECK_NEVER_READ_TO_END = 0,
     CRC_CHECK_NOT_DONE = 1,
     CRC_CHECK_DONE = 2,
     CRC_CHECK_NEVER_READ_AT_ALL = 3,
     CRC_CHECK_MAX = 4,
   };
 
-  virtual ~SimpleEntryImpl();
+  ~SimpleEntryImpl() override;
 
   // Must be used to invoke a client-provided completion callback for an
   // operation initiated through the backend (e.g. create, open) so that clients
   // don't get notified after they deleted the backend (which they would not
   // expect).
   void PostClientCallback(const CompletionCallback& callback, int result);
 
   // Sets entry to STATE_UNINITIALIZED.
   void MakeUninitialized();
 
@@ skipping 212 matching lines @@
   // 1 on disk, to reduce the number of file descriptors and save disk space.
   // This strategy allows stream 1 to change size easily. Since stream 0 is only
   // used to write HTTP headers, the memory consumption of keeping it in memory
   // is acceptable.
   scoped_refptr<net::GrowableIOBuffer> stream_0_data_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_