Standardize usage of virtual/override/final in net/

net/url_request/url_fetcher_impl_unittest.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 "net/url_request/url_fetcher_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 49 matching lines @@
     : public TestURLRequestContextGetter {
  public:
   ThrottlingTestURLRequestContextGetter(
       base::MessageLoopProxy* io_message_loop_proxy,
       TestURLRequestContext* request_context)
       : TestURLRequestContextGetter(io_message_loop_proxy),
         context_(request_context) {
   }
 
   // TestURLRequestContextGetter:
-  virtual TestURLRequestContext* GetURLRequestContext() override {
-    return context_;
-  }
+  TestURLRequestContext* GetURLRequestContext() override { return context_; }
 
  protected:
-  virtual ~ThrottlingTestURLRequestContextGetter() {}
+  ~ThrottlingTestURLRequestContextGetter() override {}
 
   TestURLRequestContext* const context_;
 };
 
 }  // namespace
 
 class URLFetcherTest : public testing::Test,
                        public URLFetcherDelegate {
  public:
   URLFetcherTest() : fetcher_(NULL) {}
 
   static int GetNumFetcherCores() {
     return URLFetcherImpl::GetNumFetcherCores();
   }
 
   // Creates a URLFetcher, using the program's main thread to do IO.
   virtual void CreateFetcher(const GURL& url);
 
   // URLFetcherDelegate:
   // Subclasses that override this should either call this function or
   // CleanupAfterFetchComplete() at the end of their processing, depending on
   // whether they want to check for a non-empty HTTP 200 response or not.
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
 
   // Deletes |fetcher| and terminates the message loop.
   void CleanupAfterFetchComplete();
 
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy() {
     return io_message_loop_proxy_;
   }
 
   TestURLRequestContext* request_context() {
     return context_.get();
@@ skipping 30 matching lines @@
 };
 
 // A test fixture that uses a MockHostResolver, so that name resolutions can
 // be manipulated by the tests to keep connections in the resolving state.
 class URLFetcherMockDnsTest : public URLFetcherTest {
  public:
   // testing::Test:
   virtual void SetUp() override;
 
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) override;
+  void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
 
  protected:
   GURL test_url_;
   scoped_ptr<SpawnedTestServer> test_server_;
   MockHostResolver resolver_;
   scoped_ptr<URLFetcher> completed_fetcher_;
 };
 
 void URLFetcherTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
@@ skipping 61 matching lines @@
   EXPECT_EQ(test_url_, source->GetOriginalURL());
   completed_fetcher_.reset(fetcher_);
 }
 
 namespace {
 
 // Version of URLFetcherTest that does a POST instead
 class URLFetcherPostTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) override;
+  void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
 };
 
 // Version of URLFetcherTest that does a POST of a file using
 // SetUploadDataStream
 class URLFetcherPostFileTest : public URLFetcherTest {
  public:
   URLFetcherPostFileTest();
 
   void SetUploadRange(uint64 range_offset, uint64 range_length) {
     range_offset_ = range_offset;
     range_length_ = range_length;
   }
 
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) override;
+  void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
 
  private:
   base::FilePath path_;
   uint64 range_offset_;
   uint64 range_length_;
 };
 
 // Version of URLFetcherTest that does a POST instead with empty upload body
 class URLFetcherEmptyPostTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) override;
+  void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
 };
 
 // Version of URLFetcherTest that tests download progress reports.
 class URLFetcherDownloadProgressTest : public URLFetcherTest {
  public:
   URLFetcherDownloadProgressTest()
       : previous_progress_(0),
         expected_total_(0) {
   }
 
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) override;
+  void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchDownloadProgress(const URLFetcher* source,
-                                          int64 current,
-                                          int64 total) override;
+  void OnURLFetchDownloadProgress(const URLFetcher* source,
+                                  int64 current,
+                                  int64 total) override;
 
  protected:
   // Download progress returned by the previous callback.
   int64 previous_progress_;
   // Size of the file being downloaded, known in advance (provided by each test
   // case).
   int64 expected_total_;
 };
 
 // Version of URLFetcherTest that tests progress reports at cancellation.
 class URLFetcherDownloadProgressCancelTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) override;
+  void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
-  virtual void OnURLFetchDownloadProgress(const URLFetcher* source,
-                                          int64 current,
-                                          int64 total) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchDownloadProgress(const URLFetcher* source,
+                                  int64 current,
+                                  int64 total) override;
+
  protected:
   bool cancelled_;
 };
 
 // Version of URLFetcherTest that tests upload progress reports.
 class URLFetcherUploadProgressTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) override;
+  void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchUploadProgress(const URLFetcher* source,
-                                        int64 current,
-                                        int64 total) override;
+  void OnURLFetchUploadProgress(const URLFetcher* source,
+                                int64 current,
+                                int64 total) override;
+
  protected:
   int64 previous_progress_;
   std::string chunk_;
   int64 number_of_chunks_added_;
 };
 
 // Version of URLFetcherTest that tests headers.
 class URLFetcherHeadersTest : public URLFetcherTest {
  public:
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
 };
 
 // Version of URLFetcherTest that tests SocketAddress.
 class URLFetcherSocketAddressTest : public URLFetcherTest {
  public:
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
+
  protected:
   std::string expected_host_;
   uint16 expected_port_;
 };
 
 // Version of URLFetcherTest that tests stopping on a redirect.
 class URLFetcherStopOnRedirectTest : public URLFetcherTest {
  public:
   URLFetcherStopOnRedirectTest();
   virtual ~URLFetcherStopOnRedirectTest();
 
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) override;
+  void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
 
  protected:
   // The URL we should be redirected to.
   static const char* kRedirectTarget;
 
   bool callback_called_;  // Set to true in OnURLFetchComplete().
 };
 
 // Version of URLFetcherTest that tests overload protection.
 class URLFetcherProtectTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) override;
+  void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
+
  private:
   Time start_time_;
 };
 
 // Version of URLFetcherTest that tests overload protection, when responses
 // passed through.
 class URLFetcherProtectTestPassedThrough : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) override;
+  void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
+
  private:
   Time start_time_;
 };
 
 // Version of URLFetcherTest that tests bad HTTPS requests.
 class URLFetcherBadHTTPSTest : public URLFetcherTest {
  public:
   URLFetcherBadHTTPSTest();
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
 
  private:
   base::FilePath cert_dir_;
 };
 
 // Version of URLFetcherTest that tests request cancellation on shutdown.
 class URLFetcherCancelTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) override;
+  void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
 
   void CancelRequest();
 };
 
 // Version of TestURLRequestContext that posts a Quit task to the IO
 // thread once it is deleted.
 class CancelTestURLRequestContext : public ThrottlingTestURLRequestContext {
  public:
   explicit CancelTestURLRequestContext() {
   }
 
  private:
-  virtual ~CancelTestURLRequestContext() {
+  ~CancelTestURLRequestContext() override {
     // The d'tor should execute in the IO thread. Post the quit task to the
     // current thread.
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
   }
 };
 
 class CancelTestURLRequestContextGetter
     : public TestURLRequestContextGetter {
  public:
   CancelTestURLRequestContextGetter(
       base::MessageLoopProxy* io_message_loop_proxy,
       const GURL& throttle_for_url)
       : TestURLRequestContextGetter(io_message_loop_proxy),
         io_message_loop_proxy_(io_message_loop_proxy),
         context_created_(false, false),
         throttle_for_url_(throttle_for_url) {
   }
 
   // TestURLRequestContextGetter:
-  virtual TestURLRequestContext* GetURLRequestContext() override {
+  TestURLRequestContext* GetURLRequestContext() override {
     if (!context_.get()) {
       context_.reset(new CancelTestURLRequestContext());
       DCHECK(context_->throttler_manager());
 
       // Registers an entry for test url. The backoff time is calculated by:
       //     new_backoff = 2.0 * old_backoff + 0
       // The initial backoff is 2 seconds and maximum backoff is 4 seconds.
       // Maximum retries allowed is set to 2.
       scoped_refptr<URLRequestThrottlerEntry> entry(
           new URLRequestThrottlerEntry(context_->throttler_manager(),
@@ skipping 14 matching lines @@
 
   virtual scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() const {
     return io_message_loop_proxy_;
   }
 
   void WaitForContextCreation() {
     context_created_.Wait();
   }
 
  protected:
-  virtual ~CancelTestURLRequestContextGetter() {}
+  ~CancelTestURLRequestContextGetter() override {}
 
  private:
   scoped_ptr<TestURLRequestContext> context_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
   base::WaitableEvent context_created_;
   GURL throttle_for_url_;
 };
 
 // Version of URLFetcherTest that tests retying the same request twice.
 class URLFetcherMultipleAttemptTest : public URLFetcherTest {
  public:
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
+
  private:
   std::string data_;
 };
 
 class URLFetcherFileTest : public URLFetcherTest {
  public:
   URLFetcherFileTest() : take_ownership_of_file_(false),
                          expected_file_error_(OK) {}
 
   void CreateFetcherForFile(const GURL& url, const base::FilePath& file_path);
   void CreateFetcherForTempFile(const GURL& url);
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) override;
+  void OnURLFetchComplete(const URLFetcher* source) override;
 
  protected:
   base::FilePath expected_file_;
   base::FilePath file_path_;
 
   // Set by the test. Used in OnURLFetchComplete() to decide if
   // the URLFetcher should own the temp file, so that we can test
   // disowning prevents the file from being deleted.
   bool take_ownership_of_file_;
 
@@ skipping 1014 matching lines @@
 
     base::MessageLoop::current()->RunUntilIdle();
     ASSERT_EQ(kTake[i], base::PathExists(file_path_)) <<
         "FilePath: " << file_path_.value();
   }
 }
 
 }  // namespace
 
 }  // namespace net