Replacing the OVERRIDE with override and FINAL with final in content/browser/[download|…

content/browser/download/download_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.
 
 // This file contains download browser tests that are known to be runnable
 // in a pure content context.  Over time tests should be migrated here.
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 111 matching lines @@
       base::WeakPtr<DownloadDestinationObserver> observer,
       base::WeakPtr<DownloadFileWithDelayFactory> owner);
 
   virtual ~DownloadFileWithDelay();
 
   // Wraps DownloadFileImpl::Rename* and intercepts the return callback,
   // storing it in the factory that produced this object for later
   // retrieval.
   virtual void RenameAndUniquify(
       const base::FilePath& full_path,
-      const RenameCompletionCallback& callback) OVERRIDE;
+      const RenameCompletionCallback& callback) override;
   virtual void RenameAndAnnotate(
       const base::FilePath& full_path,
-      const RenameCompletionCallback& callback) OVERRIDE;
+      const RenameCompletionCallback& callback) override;
 
  private:
   static void RenameCallbackWrapper(
       const base::WeakPtr<DownloadFileWithDelayFactory>& factory,
       const RenameCompletionCallback& original_callback,
       DownloadInterruptReason reason,
       const base::FilePath& path);
 
   // This variable may only be read on the FILE thread, and may only be
   // indirected through (e.g. methods on DownloadFileWithDelayFactory called)
@@ skipping 13 matching lines @@
 
   // DownloadFileFactory interface.
   virtual DownloadFile* CreateFile(
       scoped_ptr<DownloadSaveInfo> save_info,
       const base::FilePath& default_download_directory,
       const GURL& url,
       const GURL& referrer_url,
       bool calculate_hash,
       scoped_ptr<ByteStreamReader> stream,
       const net::BoundNetLog& bound_net_log,
-      base::WeakPtr<DownloadDestinationObserver> observer) OVERRIDE;
+      base::WeakPtr<DownloadDestinationObserver> observer) override;
 
   void AddRenameCallback(base::Closure callback);
   void GetAllRenameCallbacks(std::vector<base::Closure>* results);
 
   // Do not return until GetAllRenameCallbacks() will return a non-empty list.
   void WaitForSomeCallback();
 
  private:
   base::WeakPtrFactory<DownloadFileWithDelayFactory> weak_ptr_factory_;
   std::vector<base::Closure> rename_callbacks_;
@@ skipping 110 matching lines @@
     base::WeakPtr<DownloadDestinationObserver> observer)
       : DownloadFileImpl(save_info.Pass(), default_downloads_directory,
                          url, referrer_url, calculate_hash,
                          stream.Pass(), bound_net_log, observer) {}
 
   virtual ~CountingDownloadFile() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     active_files_--;
   }
 
-  virtual void Initialize(const InitializeCallback& callback) OVERRIDE {
+  virtual void Initialize(const InitializeCallback& callback) override {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     active_files_++;
     return DownloadFileImpl::Initialize(callback);
   }
 
   static void GetNumberActiveFiles(int* result) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     *result = active_files_;
   }
 
@@ skipping 24 matching lines @@
 
   // DownloadFileFactory interface.
   virtual DownloadFile* CreateFile(
     scoped_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_downloads_directory,
     const GURL& url,
     const GURL& referrer_url,
     bool calculate_hash,
     scoped_ptr<ByteStreamReader> stream,
     const net::BoundNetLog& bound_net_log,
-    base::WeakPtr<DownloadDestinationObserver> observer) OVERRIDE {
+    base::WeakPtr<DownloadDestinationObserver> observer) override {
     scoped_ptr<PowerSaveBlocker> psb(
         PowerSaveBlocker::Create(
             PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
             "Download in progress"));
     return new CountingDownloadFile(
         save_info.Pass(), default_downloads_directory, url, referrer_url,
         calculate_hash, stream.Pass(), bound_net_log,
         psb.Pass(), observer);
   }
 };
 
 class TestShellDownloadManagerDelegate : public ShellDownloadManagerDelegate {
  public:
   TestShellDownloadManagerDelegate()
       : delay_download_open_(false) {}
   virtual ~TestShellDownloadManagerDelegate() {}
 
   virtual bool ShouldOpenDownload(
       DownloadItem* item,
-      const DownloadOpenDelayedCallback& callback) OVERRIDE {
+      const DownloadOpenDelayedCallback& callback) override {
     if (delay_download_open_) {
       delayed_callbacks_.push_back(callback);
       return false;
     }
     return true;
   }
 
   void SetDelayedOpen(bool delay) {
     delay_download_open_ = delay;
   }
@@ skipping 32 matching lines @@
     EXPECT_EQ(size, record_.size());
     int min = size > record_.size() ? record_.size() : size;
     for (int i = 0; i < min; ++i) {
       EXPECT_EQ(expected[i].state, record_[i].state) << "Iteration " << i;
       EXPECT_EQ(expected[i].bytes_received, record_[i].bytes_received)
           << "Iteration " << i;
     }
   }
 
  private:
-  virtual void OnDownloadUpdated(DownloadItem* download) OVERRIDE {
+  virtual void OnDownloadUpdated(DownloadItem* download) override {
     DCHECK_EQ(download_, download);
     DownloadItem::DownloadState state = download->GetState();
     int bytes = download->GetReceivedBytes();
     if (last_state_.state != state || last_state_.bytes_received > bytes) {
       last_state_.state = state;
       last_state_.bytes_received = bytes;
       record_.push_back(last_state_);
     }
   }
 
-  virtual void OnDownloadDestroyed(DownloadItem* download) OVERRIDE {
+  virtual void OnDownloadDestroyed(DownloadItem* download) override {
     DCHECK_EQ(download_, download);
     RemoveObserver();
   }
 
   void RemoveObserver() {
     if (download_) {
       download_->RemoveObserver(this);
       download_ = NULL;
     }
   }
@@ skipping 12 matching lines @@
         waiting_(false) {
     manager_->AddObserver(this);
   }
 
   virtual ~DownloadCreateObserver() {
     if (manager_)
       manager_->RemoveObserver(this);
     manager_ = NULL;
   }
 
-  virtual void ManagerGoingDown(DownloadManager* manager) OVERRIDE {
+  virtual void ManagerGoingDown(DownloadManager* manager) override {
     DCHECK_EQ(manager_, manager);
     manager_->RemoveObserver(this);
     manager_ = NULL;
   }
 
   virtual void OnDownloadCreated(DownloadManager* manager,
-                                 DownloadItem* download) OVERRIDE {
+                                 DownloadItem* download) override {
     if (!item_)
       item_ = download;
 
     if (waiting_)
       base::MessageLoopForUI::current()->Quit();
   }
 
   DownloadItem* WaitForFinished() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!item_) {
@@ skipping 87 matching lines @@
   // help up by buffering in the underlying downloads ByteStream data
   // transfer.  This is important because on resumption tests we wait
   // until we've gotten the data we expect before allowing the test server
   // to send its reset, to get around hard close semantics on the Windows
   // socket layer implementation.
   int GetSafeBufferChunk() const {
     return (DownloadResourceHandler::kDownloadByteStreamSize /
        ByteStreamWriter::kFractionBufferBeforeSending) + 1;
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     ASSERT_TRUE(downloads_directory_.CreateUniqueTempDir());
 
     test_delegate_.reset(new TestShellDownloadManagerDelegate());
     test_delegate_->SetDownloadBehaviorForTesting(downloads_directory_.path());
     DownloadManager* manager = DownloadManagerForShell(shell());
     manager->GetDelegate()->Shutdown();
     manager->SetDelegate(test_delegate_.get());
     test_delegate_->SetDownloadManager(manager);
 
     BrowserThread::PostTask(
@@ skipping 1226 matching lines @@
   ASSERT_TRUE(test_server.InitializeAndWaitUntilReady());
 
   GURL url = test_server.GetURL("/empty.bin");
   test_server.ServeFilesFromDirectory(GetTestFilePath("download", ""));
 
   NavigateToURLAndWaitForDownload(shell(), url, DownloadItem::COMPLETE);
   // That's it. This should work without crashing.
 }
 
 }  // namespace content