Standardize usage of virtual/override/final in net/

net/disk_cache/blockfile/in_flight_backend_io.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_DISK_CACHE_BLOCKFILE_IN_FLIGHT_BACKEND_IO_H_
 #define NET_DISK_CACHE_BLOCKFILE_IN_FLIGHT_BACKEND_IO_H_
 
 #include <list>
 #include <string>
 
@@ skipping 89 matching lines @@
     OP_MAX_BACKEND,
     OP_READ,
     OP_WRITE,
     OP_READ_SPARSE,
     OP_WRITE_SPARSE,
     OP_GET_RANGE,
     OP_CANCEL_IO,
     OP_IS_READY
   };
 
-  virtual ~BackendIO();
+  ~BackendIO() override;
 
   // Returns true if this operation returns an entry.
   bool ReturnsEntry();
 
   // Returns the time that has passed since the operation was created.
   base::TimeDelta ElapsedTime() const;
 
   void ExecuteBackendOperation();
   void ExecuteEntryOperation();
 
@@ skipping 21 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(BackendIO);
 };
 
 // The specialized controller that keeps track of current operations.
 class InFlightBackendIO : public InFlightIO {
  public:
   InFlightBackendIO(
       BackendImpl* backend,
       const scoped_refptr<base::SingleThreadTaskRunner>& background_thread);
-  virtual ~InFlightBackendIO();
+  ~InFlightBackendIO() override;
 
   // Proxied operations.
   void Init(const net::CompletionCallback& callback);
   void OpenEntry(const std::string& key, Entry** entry,
                  const net::CompletionCallback& callback);
   void CreateEntry(const std::string& key, Entry** entry,
                    const net::CompletionCallback& callback);
   void DoomEntry(const std::string& key,
                  const net::CompletionCallback& callback);
   void DoomAllEntries(const net::CompletionCallback& callback);
@@ skipping 34 matching lines @@
   }
 
   // Returns true if the current thread is the background thread.
   bool BackgroundIsCurrentThread() {
     return background_thread_->RunsTasksOnCurrentThread();
   }
 
   base::WeakPtr<InFlightBackendIO> GetWeakPtr();
 
  protected:
-  virtual void OnOperationComplete(BackgroundIO* operation,
-                                   bool cancel) override;
+  void OnOperationComplete(BackgroundIO* operation, bool cancel) override;
 
  private:
   void PostOperation(BackendIO* operation);
 
   BackendImpl* backend_;
   scoped_refptr<base::SingleThreadTaskRunner> background_thread_;
   base::WeakPtrFactory<InFlightBackendIO> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InFlightBackendIO);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BLOCKFILE_IN_FLIGHT_BACKEND_IO_H_