Standardize usage of virtual/override/final in content/

content/public/test/download_test_observer.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 CONTENT_TEST_DOWNLOAD_TEST_OBSERVER_H_
 #define CONTENT_TEST_DOWNLOAD_TEST_OBSERVER_H_
 
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/download_url_parameters.h"
 
 namespace content {
 
 // Detects an arbitrary change on a download item.
 // TODO: Rewrite other observers to use this (or be replaced by it).
 class DownloadUpdatedObserver : public DownloadItem::Observer {
  public:
   typedef base::Callback<bool(DownloadItem*)> EventFilter;
 
   // The filter passed may be called multiple times, even after it
   // returns true.
   DownloadUpdatedObserver(DownloadItem* item, EventFilter filter);
-  virtual ~DownloadUpdatedObserver();
+  ~DownloadUpdatedObserver() override;
 
   // Returns when either the event has been seen (at least once since
   // object construction) or the item is destroyed.  Return value indicates
   // if the wait ended because the item was seen (true) or the object
   // destroyed (false).
   bool WaitForEvent();
 
  private:
   // DownloadItem::Observer
-  virtual void OnDownloadUpdated(DownloadItem* item) override;
-  virtual void OnDownloadDestroyed(DownloadItem* item) override;
+  void OnDownloadUpdated(DownloadItem* item) override;
+  void OnDownloadDestroyed(DownloadItem* item) override;
 
   DownloadItem* item_;
   EventFilter filter_;
   bool waiting_;
   bool event_seen_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadUpdatedObserver);
 };
 
 // Detects changes to the downloads after construction.
@@ skipping 15 matching lines @@
     ON_DANGEROUS_DOWNLOAD_IGNORE,  // Make it the callers problem.
     ON_DANGEROUS_DOWNLOAD_QUIT     // Will set final state without decision.
   };
 
   // Create an object that will be considered finished when |wait_count|
   // download items have entered a terminal state.
   DownloadTestObserver(DownloadManager* download_manager,
                        size_t wait_count,
                        DangerousDownloadAction dangerous_download_action);
 
-  virtual ~DownloadTestObserver();
+  ~DownloadTestObserver() override;
 
   // Wait for one of the finish conditions.
   void WaitForFinished();
 
   // Return true if we reached one of the finish conditions.
   bool IsFinished() const;
 
   // DownloadItem::Observer
-  virtual void OnDownloadUpdated(DownloadItem* download) override;
-  virtual void OnDownloadDestroyed(DownloadItem* download) override;
+  void OnDownloadUpdated(DownloadItem* download) override;
+  void OnDownloadDestroyed(DownloadItem* download) override;
 
   // DownloadManager::Observer
-  virtual void OnDownloadCreated(
-      DownloadManager* manager, DownloadItem* item) override;
-  virtual void ManagerGoingDown(DownloadManager* manager) override;
+  void OnDownloadCreated(DownloadManager* manager, DownloadItem* item) override;
+  void ManagerGoingDown(DownloadManager* manager) override;
 
   size_t NumDangerousDownloadsSeen() const;
 
   size_t NumDownloadsSeenInState(DownloadItem::DownloadState state) const;
 
  protected:
   // Only to be called by derived classes' constructors.
   virtual void Init();
 
   // Called to see if a download item is in a final state.
@@ skipping 68 matching lines @@
 class DownloadTestObserverTerminal : public DownloadTestObserver {
  public:
   // Create an object that will be considered finished when |wait_count|
   // download items have entered a terminal state (DownloadItem::IsDone() is
   // true).
   DownloadTestObserverTerminal(
       DownloadManager* download_manager,
       size_t wait_count,
       DangerousDownloadAction dangerous_download_action);
 
-  virtual ~DownloadTestObserverTerminal();
+  ~DownloadTestObserverTerminal() override;
 
  private:
-  virtual bool IsDownloadInFinalState(DownloadItem* download) override;
+  bool IsDownloadInFinalState(DownloadItem* download) override;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadTestObserverTerminal);
 };
 
 // Detects changes to the downloads after construction.
 // Finishes when a specified number of downloads change to the
 // IN_PROGRESS state, or when the download manager is destroyed.
 // Dangerous downloads are accepted.
 // Callers may either probe for the finished state, or wait on it.
 class DownloadTestObserverInProgress : public DownloadTestObserver {
  public:
   // Create an object that will be considered finished when |wait_count|
   // download items have entered state |IN_PROGRESS|.
   DownloadTestObserverInProgress(
       DownloadManager* download_manager, size_t wait_count);
 
-  virtual ~DownloadTestObserverInProgress();
+  ~DownloadTestObserverInProgress() override;
 
  private:
-  virtual bool IsDownloadInFinalState(DownloadItem* download) override;
+  bool IsDownloadInFinalState(DownloadItem* download) override;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadTestObserverInProgress);
 };
 
 class DownloadTestObserverInterrupted : public DownloadTestObserver {
  public:
   // Create an object that will be considered finished when |wait_count|
   // download items are interrupted.
   DownloadTestObserverInterrupted(
       DownloadManager* download_manager,
       size_t wait_count,
       DangerousDownloadAction dangerous_download_action);
 
-  virtual ~DownloadTestObserverInterrupted();
+  ~DownloadTestObserverInterrupted() override;
 
  private:
-  virtual bool IsDownloadInFinalState(DownloadItem* download) override;
+  bool IsDownloadInFinalState(DownloadItem* download) override;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadTestObserverInterrupted);
 };
 
 // The WaitForFlush() method on this class returns after:
 //      * There are no IN_PROGRESS download items remaining on the
 //        DownloadManager.
 //      * There have been two round trip messages through the file and
 //        IO threads.
 // This almost certainly means that a Download cancel has propagated through
 // the system.
 class DownloadTestFlushObserver
     : public DownloadManager::Observer,
       public DownloadItem::Observer,
       public base::RefCountedThreadSafe<DownloadTestFlushObserver> {
  public:
   explicit DownloadTestFlushObserver(DownloadManager* download_manager);
 
   void WaitForFlush();
 
   // DownloadsManager observer methods.
-  virtual void OnDownloadCreated(
-      DownloadManager* manager,
-      DownloadItem* item) override;
+  void OnDownloadCreated(DownloadManager* manager, DownloadItem* item) override;
 
   // DownloadItem observer methods.
-  virtual void OnDownloadUpdated(DownloadItem* download) override;
-  virtual void OnDownloadDestroyed(DownloadItem* download) override;
+  void OnDownloadUpdated(DownloadItem* download) override;
+  void OnDownloadDestroyed(DownloadItem* download) override;
 
  protected:
   friend class base::RefCountedThreadSafe<DownloadTestFlushObserver>;
 
-  virtual ~DownloadTestFlushObserver();
+  ~DownloadTestFlushObserver() override;
 
  private:
   typedef std::set<DownloadItem*> DownloadSet;
 
   // If we're waiting for that flush point, check the number
   // of downloads in the IN_PROGRESS state and take appropriate
   // action.  If requested, also observes all downloads while iterating.
   void CheckDownloadsInProgress(bool observe_downloads);
 
   void PingFileThread(int cycle);
@@ skipping 42 matching lines @@
 
   // We are in the message loop.
   bool waiting_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadTestItemCreationObserver);
 };
 
 }  // namespace content`
 
 #endif  // CONTENT_TEST_DOWNLOAD_TEST_OBSERVER_H_