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

content/browser/loader/resource_scheduler_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 "content/browser/loader/resource_scheduler.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 38 matching lines @@
 
 class TestRequest : public ResourceController {
  public:
   TestRequest(scoped_ptr<ResourceThrottle> throttle,
               scoped_ptr<net::URLRequest> url_request)
       : started_(false),
         throttle_(throttle.Pass()),
         url_request_(url_request.Pass()) {
     throttle_->set_controller_for_testing(this);
   }
-  virtual ~TestRequest() {}
+  ~TestRequest() override {}
 
   bool started() const { return started_; }
 
   void Start() {
     bool deferred = false;
     throttle_->WillStartRequest(&deferred);
     started_ = !deferred;
   }
 
-  virtual void Cancel() override {
+  void Cancel() override {
     // Alert the scheduler that the request can be deleted.
     throttle_.reset(0);
   }
 
   const net::URLRequest* url_request() const { return url_request_.get(); }
 
  protected:
   // ResourceController interface:
-  virtual void CancelAndIgnore() override {}
-  virtual void CancelWithError(int error_code) override {}
-  virtual void Resume() override { started_ = true; }
+  void CancelAndIgnore() override {}
+  void CancelWithError(int error_code) override {}
+  void Resume() override { started_ = true; }
 
  private:
   bool started_;
   scoped_ptr<ResourceThrottle> throttle_;
   scoped_ptr<net::URLRequest> url_request_;
 };
 
 class CancelingTestRequest : public TestRequest {
  public:
   CancelingTestRequest(scoped_ptr<ResourceThrottle> throttle,
                        scoped_ptr<net::URLRequest> url_request)
       : TestRequest(throttle.Pass(), url_request.Pass()) {}
 
   void set_request_to_cancel(scoped_ptr<TestRequest> request_to_cancel) {
     request_to_cancel_ = request_to_cancel.Pass();
   }
 
  private:
-  virtual void Resume() override {
+  void Resume() override {
     TestRequest::Resume();
     request_to_cancel_.reset();
   }
 
   scoped_ptr<TestRequest> request_to_cancel_;
 };
 
 class FakeResourceContext : public ResourceContext {
  private:
-  virtual net::HostResolver* GetHostResolver() override { return NULL; }
-  virtual net::URLRequestContext* GetRequestContext() override { return NULL; }
+  net::HostResolver* GetHostResolver() override { return NULL; }
+  net::URLRequestContext* GetRequestContext() override { return NULL; }
 };
 
 class FakeResourceMessageFilter : public ResourceMessageFilter {
  public:
   FakeResourceMessageFilter(int child_id)
       : ResourceMessageFilter(
           child_id,
           PROCESS_TYPE_RENDERER,
           NULL  /* appcache_service */,
           NULL  /* blob_storage_context */,
           NULL  /* file_system_context */,
           NULL  /* service_worker_context */,
           base::Bind(&FakeResourceMessageFilter::GetContexts,
                      base::Unretained(this))) {
   }
 
  private:
-  virtual ~FakeResourceMessageFilter() {}
+  ~FakeResourceMessageFilter() override {}
 
   void GetContexts(const ResourceHostMsg_Request& request,
                    ResourceContext** resource_context,
                    net::URLRequestContext** request_context) {
     *resource_context = &context_;
     *request_context = NULL;
   }
 
   FakeResourceContext context_;
 };
@@ skipping 2064 matching lines @@
   web_contents_2.reset();
   base::RunLoop().RunUntilIdle();
 
   browser_context.reset();
   render_process_host_factory.reset();
 }
 
 }  // unnamed namespace
 
 }  // namespace content