Standardize usage of virtual/override/final in chrome/browser/download/

chrome/browser/download/save_page_browsertest.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.
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 50 matching lines @@
 
   DownloadPersistedObserver(Profile* profile, const PersistedFilter& filter)
     : profile_(profile),
       filter_(filter),
       waiting_(false),
       persisted_(false) {
     DownloadServiceFactory::GetForBrowserContext(profile_)->
       GetDownloadHistory()->AddObserver(this);
   }
 
-  virtual ~DownloadPersistedObserver() {
+  ~DownloadPersistedObserver() override {
     DownloadService* service = DownloadServiceFactory::GetForBrowserContext(
         profile_);
     if (service && service->GetDownloadHistory())
       service->GetDownloadHistory()->RemoveObserver(this);
   }
 
   bool WaitForPersisted() {
     if (persisted_)
       return true;
     waiting_ = true;
     content::RunMessageLoop();
     waiting_ = false;
     return persisted_;
   }
 
-  virtual void OnDownloadStored(DownloadItem* item,
-                                const history::DownloadRow& info) override {
+  void OnDownloadStored(DownloadItem* item,
+                        const history::DownloadRow& info) override {
     persisted_ = persisted_ || filter_.Run(item, info);
     if (persisted_ && waiting_)
       base::MessageLoopForUI::current()->Quit();
   }
 
  private:
   Profile* profile_;
   PersistedFilter filter_;
   bool waiting_;
   bool persisted_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadPersistedObserver);
 };
 
 // Waits for an item record to be removed from the downloads database.
 class DownloadRemovedObserver : public DownloadPersistedObserver {
  public:
   DownloadRemovedObserver(Profile* profile, int32 download_id)
       : DownloadPersistedObserver(profile, PersistedFilter()),
         removed_(false),
         waiting_(false),
         download_id_(download_id) {
   }
-  virtual ~DownloadRemovedObserver() {}
+  ~DownloadRemovedObserver() override {}
 
   bool WaitForRemoved() {
     if (removed_)
       return true;
     waiting_ = true;
     content::RunMessageLoop();
     waiting_ = false;
     return removed_;
   }
 
-  virtual void OnDownloadStored(DownloadItem* item,
-                                const history::DownloadRow& info) override {
-  }
+  void OnDownloadStored(DownloadItem* item,
+                        const history::DownloadRow& info) override {}
 
-  virtual void OnDownloadsRemoved(const DownloadHistory::IdSet& ids) override {
+  void OnDownloadsRemoved(const DownloadHistory::IdSet& ids) override {
     removed_ = ids.find(download_id_) != ids.end();
     if (removed_ && waiting_)
       base::MessageLoopForUI::current()->Quit();
   }
 
  private:
   bool removed_;
   bool waiting_;
   int32 download_id_;
 
@@ skipping 43 matching lines @@
 static const char kAppendedExtension[] = ".html";
 
 // Loosely based on logic in DownloadTestObserver.
 class DownloadItemCreatedObserver : public DownloadManager::Observer {
  public:
   explicit DownloadItemCreatedObserver(DownloadManager* manager)
       : waiting_(false), manager_(manager) {
     manager->AddObserver(this);
   }
 
-  virtual ~DownloadItemCreatedObserver() {
+  ~DownloadItemCreatedObserver() override {
     if (manager_)
       manager_->RemoveObserver(this);
   }
 
   // Wait for the first download item created after object creation.
   // Note that this class provides no protection against the download
   // being destroyed between creation and return of WaitForNewDownloadItem();
   // the caller must guarantee that in some other fashion.
   void WaitForDownloadItem(std::vector<DownloadItem*>* items_seen) {
     if (!manager_) {
       // The manager went away before we were asked to wait; return
       // what we have, even if it's null.
       *items_seen = items_seen_;
       return;
     }
 
     if (items_seen_.empty()) {
       waiting_ = true;
       content::RunMessageLoop();
       waiting_ = false;
     }
 
     *items_seen = items_seen_;
     return;
   }
 
  private:
   // DownloadManager::Observer
-  virtual void OnDownloadCreated(
-      DownloadManager* manager, DownloadItem* item) override {
+  void OnDownloadCreated(DownloadManager* manager,
+                         DownloadItem* item) override {
     DCHECK_EQ(manager, manager_);
     items_seen_.push_back(item);
 
     if (waiting_)
       base::MessageLoopForUI::current()->Quit();
   }
 
-  virtual void ManagerGoingDown(DownloadManager* manager) override {
+  void ManagerGoingDown(DownloadManager* manager) override {
     manager_->RemoveObserver(this);
     manager_ = NULL;
     if (waiting_)
       base::MessageLoopForUI::current()->Quit();
   }
 
   bool waiting_;
   DownloadManager* manager_;
   std::vector<DownloadItem*> items_seen_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItemCreatedObserver);
 };
 
 class SavePackageFinishedObserver : public content::DownloadManager::Observer {
  public:
   SavePackageFinishedObserver(content::DownloadManager* manager,
                               const base::Closure& callback)
       : download_manager_(manager),
         callback_(callback) {
     download_manager_->AddObserver(this);
   }
 
-  virtual ~SavePackageFinishedObserver() {
+  ~SavePackageFinishedObserver() override {
     if (download_manager_)
       download_manager_->RemoveObserver(this);
   }
 
   // DownloadManager::Observer:
-  virtual void OnSavePackageSuccessfullyFinished(
-      content::DownloadManager* manager, content::DownloadItem* item) override {
+  void OnSavePackageSuccessfullyFinished(content::DownloadManager* manager,
+                                         content::DownloadItem* item) override {
     callback_.Run();
   }
-  virtual void ManagerGoingDown(content::DownloadManager* manager) override {
+  void ManagerGoingDown(content::DownloadManager* manager) override {
     download_manager_->RemoveObserver(this);
     download_manager_ = NULL;
   }
 
  private:
   content::DownloadManager* download_manager_;
   base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SavePackageFinishedObserver);
 };
 
 class SavePageBrowserTest : public InProcessBrowserTest {
  public:
   SavePageBrowserTest() {}
   virtual ~SavePageBrowserTest();
 
  protected:
   virtual void SetUp() override {
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_dir_));
     ASSERT_TRUE(save_dir_.CreateUniqueTempDir());
     InProcessBrowserTest::SetUp();
   }
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     browser()->profile()->GetPrefs()->SetFilePath(
         prefs::kDownloadDefaultDirectory, save_dir_.path());
     browser()->profile()->GetPrefs()->SetFilePath(
         prefs::kSaveFileDefaultDirectory, save_dir_.path());
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
   }
 
   GURL NavigateToMockURL(const std::string& prefix) {
@@ skipping 139 matching lines @@
 
   // TODO(benjhayden): Figure out how to safely wait for SavePackage's finished
   // notification, then expect the contents of the downloaded file.
 }
 
 class DelayingDownloadManagerDelegate : public ChromeDownloadManagerDelegate {
  public:
   explicit DelayingDownloadManagerDelegate(Profile* profile)
     : ChromeDownloadManagerDelegate(profile) {
   }
-  virtual ~DelayingDownloadManagerDelegate() {}
+  ~DelayingDownloadManagerDelegate() override {}
 
-  virtual bool ShouldCompleteDownload(
+  bool ShouldCompleteDownload(
       content::DownloadItem* item,
       const base::Closure& user_complete_callback) override {
     return false;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DelayingDownloadManagerDelegate);
 };
 
 // Disabled on Windows due to flakiness. http://crbug.com/162323
@@ skipping 292 matching lines @@
 
   EXPECT_TRUE(base::DieFileDie(full_file_name, false));
   EXPECT_TRUE(base::DieFileDie(dir, true));
 }
 #endif
 
 class SavePageAsMHTMLBrowserTest : public SavePageBrowserTest {
  public:
   SavePageAsMHTMLBrowserTest() {}
   virtual ~SavePageAsMHTMLBrowserTest();
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kSavePageAsMHTML);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SavePageAsMHTMLBrowserTest);
 };
 
 SavePageAsMHTMLBrowserTest::~SavePageAsMHTMLBrowserTest() {
 }
 
@@ skipping 38 matching lines @@
   base::FilePath download_dir = DownloadPrefs::FromDownloadManager(
       GetDownloadManager())->DownloadPath();
   base::FilePath filename = download_dir.AppendASCII("dataurl.txt");
   ASSERT_TRUE(base::PathExists(filename));
   std::string contents;
   EXPECT_TRUE(base::ReadFileToString(filename, &contents));
   EXPECT_EQ("foo", contents);
 }
 
 }  // namespace