Standardize usage of virtual/override/final in content/browser/

content/browser/appcache/appcache_url_request_job_unittest.cc

 // Copyright 2014 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 <stack>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 28 matching lines @@
 const char kHttpBasicBody[] = "Hello";
 
 const int kNumBlocks = 4;
 const int kBlockSize = 1024;
 
 class MockURLRequestJobFactory : public net::URLRequestJobFactory {
  public:
   MockURLRequestJobFactory() : job_(NULL) {
   }
 
-  virtual ~MockURLRequestJobFactory() {
-    DCHECK(!job_);
-  }
+  ~MockURLRequestJobFactory() override { DCHECK(!job_); }
 
   void SetJob(net::URLRequestJob* job) {
     job_ = job;
   }
 
   bool has_job() const {
     return job_ != NULL;
   }
 
   // net::URLRequestJobFactory implementation.
-  virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
+  net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
     if (job_) {
       net::URLRequestJob* temp = job_;
       job_ = NULL;
       return temp;
     } else {
       return new net::URLRequestErrorJob(request,
                                          network_delegate,
                                          net::ERR_INTERNET_DISCONNECTED);
     }
   }
 
-  virtual bool IsHandledProtocol(const std::string& scheme) const override {
+  bool IsHandledProtocol(const std::string& scheme) const override {
     return scheme == "http";
   };
 
-  virtual bool IsHandledURL(const GURL& url) const override {
+  bool IsHandledURL(const GURL& url) const override {
     return url.SchemeIs("http");
   }
 
-  virtual bool IsSafeRedirectTarget(const GURL& location) const override {
+  bool IsSafeRedirectTarget(const GURL& location) const override {
     return false;
   }
 
  private:
   mutable net::URLRequestJob* job_;
 };
 
 class AppCacheURLRequestJobTest : public testing::Test {
  public:
 
   // Test Harness -------------------------------------------------------------
   // TODO(michaeln): share this test harness with AppCacheResponseTest
 
   class MockStorageDelegate : public AppCacheStorage::Delegate {
    public:
     explicit MockStorageDelegate(AppCacheURLRequestJobTest* test)
         : loaded_info_id_(0), test_(test) {
     }
 
-    virtual void OnResponseInfoLoaded(AppCacheResponseInfo* info,
-                                      int64 response_id) override {
+    void OnResponseInfoLoaded(AppCacheResponseInfo* info,
+                              int64 response_id) override {
       loaded_info_ = info;
       loaded_info_id_ = response_id;
       test_->ScheduleNextTask();
     }
 
     scoped_refptr<AppCacheResponseInfo> loaded_info_;
     int64 loaded_info_id_;
     AppCacheURLRequestJobTest* test_;
   };
 
   class MockURLRequestDelegate : public net::URLRequest::Delegate {
    public:
     explicit MockURLRequestDelegate(AppCacheURLRequestJobTest* test)
         : test_(test),
           received_data_(new net::IOBuffer(kNumBlocks * kBlockSize)),
           did_receive_headers_(false), amount_received_(0),
           kill_after_amount_received_(0), kill_with_io_pending_(false) {
     }
 
-    virtual void OnResponseStarted(net::URLRequest* request) override {
+    void OnResponseStarted(net::URLRequest* request) override {
       amount_received_ = 0;
       did_receive_headers_ = false;
       if (request->status().is_success()) {
         EXPECT_TRUE(request->response_headers());
         did_receive_headers_ = true;
         received_info_ = request->response_info();
         ReadSome(request);
       } else {
         RequestComplete();
       }
     }
 
-    virtual void OnReadCompleted(net::URLRequest* request,
-                                 int bytes_read) override {
+    void OnReadCompleted(net::URLRequest* request, int bytes_read) override {
       if (bytes_read > 0) {
         amount_received_ += bytes_read;
 
         if (kill_after_amount_received_ && !kill_with_io_pending_) {
           if (amount_received_ >= kill_after_amount_received_) {
             request->Cancel();
             return;
           }
         }
 
@@ skipping 703 matching lines @@
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequest);
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
 }  // namespace
 
 }  // namespace content