Standardize usage of virtual/override/final in net/

net/tools/get_server_time/get_server_time.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.
 
 // This is a small utility that snarfs the server time from the
 // response headers of an http/https HEAD request and compares it to
 // the local time.
 //
 // TODO(akalin): Also snarf the server time from the TLS handshake, if
 // any (http://crbug.com/146090).
@@ skipping 54 matching lines @@
 //
 // TODO(akalin): Figure out the real resolution.
 const int64 kTimeResolutionMs = kTicksResolutionMs;
 
 // Simply quits the current message loop when finished.  Used to make
 // URLFetcher synchronous.
 class QuitDelegate : public net::URLFetcherDelegate {
  public:
   QuitDelegate() {}
 
-  virtual ~QuitDelegate() {}
+  ~QuitDelegate() override {}
 
   // net::URLFetcherDelegate implementation.
-  virtual void OnURLFetchComplete(const net::URLFetcher* source) override {
+  void OnURLFetchComplete(const net::URLFetcher* source) override {
     base::MessageLoop::current()->Quit();
   }
 
-  virtual void OnURLFetchDownloadProgress(
-      const net::URLFetcher* source,
-      int64 current, int64 total) override {
+  void OnURLFetchDownloadProgress(const net::URLFetcher* source,
+                                  int64 current,
+                                  int64 total) override {
     NOTREACHED();
   }
 
-  virtual void OnURLFetchUploadProgress(const net::URLFetcher* source,
-                                        int64 current, int64 total) override {
+  void OnURLFetchUploadProgress(const net::URLFetcher* source,
+                                int64 current,
+                                int64 total) override {
     NOTREACHED();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuitDelegate);
 };
 
 // NetLog::ThreadSafeObserver implementation that simply prints events
 // to the logs.
 class PrintingLogObserver : public net::NetLog::ThreadSafeObserver {
  public:
   PrintingLogObserver() {}
 
-  virtual ~PrintingLogObserver() {
+  ~PrintingLogObserver() override {
     // This is guaranteed to be safe as this program is single threaded.
     net_log()->RemoveThreadSafeObserver(this);
   }
 
   // NetLog::ThreadSafeObserver implementation:
-  virtual void OnAddEntry(const net::NetLog::Entry& entry) override {
+  void OnAddEntry(const net::NetLog::Entry& entry) override {
     // The log level of the entry is unknown, so just assume it maps
     // to VLOG(1).
     if (!VLOG_IS_ON(1))
       return;
 
     const char* const source_type =
         net::NetLog::SourceTypeToString(entry.source().type);
     const char* const event_type =
         net::NetLog::EventTypeToString(entry.type());
     const char* const event_phase =
@@ skipping 195 matching lines @@
                &skew, &skew_uncertainty);
 
   std::printf(
       "An estimate for the local clock skew is %.2f ms with "
       "uncertainty %.2f ms\n",
       skew.InMillisecondsF(),
       skew_uncertainty.InMillisecondsF());
 
   return EXIT_SUCCESS;
 }