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

content/browser/loader/resource_dispatcher_host_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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 205 matching lines @@
         canceled_(false),
         received_after_canceled_(0) {
     ChildProcessSecurityPolicyImpl::GetInstance()->Add(child_id());
     set_peer_pid_for_testing(base::GetCurrentProcId());
   }
 
   void set_canceled(bool canceled) { canceled_ = canceled; }
   int received_after_canceled() const { return received_after_canceled_; }
 
   // ResourceMessageFilter override
-  virtual bool Send(IPC::Message* msg) override {
+  bool Send(IPC::Message* msg) override {
     // No messages should be received when the process has been canceled.
     if (canceled_)
       received_after_canceled_++;
     ReleaseHandlesInMessage(*msg);
     delete msg;
     return true;
   }
 
   ResourceContext* resource_context() { return resource_context_; }
 
  protected:
-  virtual ~TestFilter() {}
+  ~TestFilter() override {}
 
  private:
   void GetContexts(const ResourceHostMsg_Request& request,
                    ResourceContext** resource_context,
                    net::URLRequestContext** request_context) {
     *resource_context = resource_context_;
     *request_context = resource_context_->GetRequestContext();
   }
 
   ResourceContext* resource_context_;
   bool canceled_;
   int received_after_canceled_;
 
   DISALLOW_COPY_AND_ASSIGN(TestFilter);
 };
 
 
 // This class forwards the incoming messages to the ResourceDispatcherHostTest.
 // For the test, we want all the incoming messages to go to the same place,
 // which is why this forwards.
 class ForwardingFilter : public TestFilter {
  public:
   explicit ForwardingFilter(IPC::Sender* dest,
                             ResourceContext* resource_context)
       : TestFilter(resource_context),
         dest_(dest) {
   }
 
   // TestFilter override
-  virtual bool Send(IPC::Message* msg) override {
-    return dest_->Send(msg);
-  }
+  bool Send(IPC::Message* msg) override { return dest_->Send(msg); }
 
  private:
-  virtual ~ForwardingFilter() {}
+  ~ForwardingFilter() override {}
 
   IPC::Sender* dest_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardingFilter);
 };
 
 // This class is a variation on URLRequestTestJob that will call
 // URLRequest::WillStartUsingNetwork before starting.
 class URLRequestTestDelayedNetworkJob : public net::URLRequestTestJob {
  public:
   URLRequestTestDelayedNetworkJob(net::URLRequest* request,
                                   net::NetworkDelegate* network_delegate)
       : net::URLRequestTestJob(request, network_delegate) {}
 
   // Only start if not deferred for network start.
-  virtual void Start() override {
+  void Start() override {
     bool defer = false;
     NotifyBeforeNetworkStart(&defer);
     if (defer)
       return;
     net::URLRequestTestJob::Start();
   }
 
-  virtual void ResumeNetworkStart() override {
-    net::URLRequestTestJob::StartAsync();
-  }
+  void ResumeNetworkStart() override { net::URLRequestTestJob::StartAsync(); }
 
  private:
-  virtual ~URLRequestTestDelayedNetworkJob() {}
+  ~URLRequestTestDelayedNetworkJob() override {}
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestTestDelayedNetworkJob);
 };
 
 // This class is a variation on URLRequestTestJob in that it does
 // not complete start upon entry, only when specifically told to.
 class URLRequestTestDelayedStartJob : public net::URLRequestTestJob {
  public:
   URLRequestTestDelayedStartJob(net::URLRequest* request,
                                 net::NetworkDelegate* network_delegate)
@@ skipping 13 matching lines @@
                                 bool auto_advance)
       : net::URLRequestTestJob(request,
                                network_delegate,
                                response_headers,
                                response_data,
                                auto_advance) {
     Init();
   }
 
   // Do nothing until you're told to.
-  virtual void Start() override {}
+  void Start() override {}
 
   // Finish starting a URL request whose job is an instance of
   // URLRequestTestDelayedStartJob.  It is illegal to call this routine
   // with a URLRequest that does not use URLRequestTestDelayedStartJob.
   static void CompleteStart(net::URLRequest* request) {
     for (URLRequestTestDelayedStartJob* job = list_head_;
          job;
          job = job->next_) {
       if (job->request() == request) {
         job->net::URLRequestTestJob::Start();
@@ skipping 10 matching lines @@
   static void ClearQueue() {
     if (list_head_) {
       LOG(ERROR)
           << "Unreleased entries on URLRequestTestDelayedStartJob delay queue"
           << "; may result in leaks.";
       list_head_ = NULL;
     }
   }
 
  protected:
-  virtual ~URLRequestTestDelayedStartJob() {
+  ~URLRequestTestDelayedStartJob() override {
     for (URLRequestTestDelayedStartJob** job = &list_head_; *job;
          job = &(*job)->next_) {
       if (*job == this) {
         *job = (*job)->next_;
         return;
       }
     }
     NOTREACHED();
   }
 
@@ skipping 26 matching lines @@
                                      const std::string& response_headers,
                                      const std::string& response_data,
                                      bool auto_advance)
       : net::URLRequestTestJob(request,
                                network_delegate,
                                response_headers,
                                response_data,
                                auto_advance) {}
 
  protected:
-  virtual ~URLRequestTestDelayedCompletionJob() {}
+  ~URLRequestTestDelayedCompletionJob() override {}
 
  private:
-  virtual bool NextReadAsync() override { return true; }
+  bool NextReadAsync() override { return true; }
 };
 
 class URLRequestBigJob : public net::URLRequestSimpleJob {
  public:
   URLRequestBigJob(net::URLRequest* request,
                    net::NetworkDelegate* network_delegate)
       : net::URLRequestSimpleJob(request, network_delegate) {
   }
 
-  virtual int GetData(std::string* mime_type,
-                      std::string* charset,
-                      std::string* data,
-                      const net::CompletionCallback& callback) const override {
+  int GetData(std::string* mime_type,
+              std::string* charset,
+              std::string* data,
+              const net::CompletionCallback& callback) const override {
     *mime_type = "text/plain";
     *charset = "UTF-8";
 
     std::string text;
     int count;
     if (!ParseURL(request_->url(), &text, &count))
       return net::ERR_INVALID_URL;
 
     data->reserve(text.size() * count);
     for (int i = 0; i < count; ++i)
       data->append(text);
 
     return net::OK;
   }
 
  private:
-  virtual ~URLRequestBigJob() {}
+  ~URLRequestBigJob() override {}
 
   // big-job:substring,N
   static bool ParseURL(const GURL& url, std::string* text, int* count) {
     std::vector<std::string> parts;
     base::SplitString(url.path(), ',', &parts);
 
     if (parts.size() != 2)
       return false;
 
     *text = parts[0];
@@ skipping 26 matching lines @@
   }
 
   void SetDelayedCompleteJobGeneration(bool delay_job_complete) {
     delay_complete_ = delay_job_complete;
   }
 
   void SetNetworkStartNotificationJobGeneration(bool notification) {
     network_start_notification_ = notification;
   }
 
-  virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
+  net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override;
 
-  virtual bool IsHandledProtocol(const std::string& scheme) const override {
+  bool IsHandledProtocol(const std::string& scheme) const override {
     return supported_schemes_.count(scheme) > 0;
   }
 
-  virtual bool IsHandledURL(const GURL& url) const override {
+  bool IsHandledURL(const GURL& url) const override {
     return supported_schemes_.count(url.scheme()) > 0;
   }
 
-  virtual bool IsSafeRedirectTarget(const GURL& location) const override {
+  bool IsSafeRedirectTarget(const GURL& location) const override {
     return false;
   }
 
  private:
   ResourceDispatcherHostTest* test_fixture_;
   bool delay_start_;
   bool delay_complete_;
   bool network_start_notification_;
   mutable int url_request_jobs_created_count_;
   std::set<std::string> supported_schemes_;
 
   DISALLOW_COPY_AND_ASSIGN(TestURLRequestJobFactory);
 };
 
 // Associated with an URLRequest to determine if the URLRequest gets deleted.
 class TestUserData : public base::SupportsUserData::Data {
  public:
   explicit TestUserData(bool* was_deleted)
       : was_deleted_(was_deleted) {
   }
 
-  virtual ~TestUserData() {
-    *was_deleted_ = true;
-  }
+  ~TestUserData() override { *was_deleted_ = true; }
 
  private:
   bool* was_deleted_;
 };
 
 class TransfersAllNavigationsContentBrowserClient
     : public TestContentBrowserClient {
  public:
-  virtual bool ShouldSwapProcessesForRedirect(ResourceContext* resource_context,
-                                              const GURL& current_url,
-                                              const GURL& new_url) override {
+  bool ShouldSwapProcessesForRedirect(ResourceContext* resource_context,
+                                      const GURL& current_url,
+                                      const GURL& new_url) override {
     return true;
   }
 };
 
 enum GenericResourceThrottleFlags {
   NONE                      = 0,
   DEFER_STARTING_REQUEST    = 1 << 0,
   DEFER_PROCESSING_RESPONSE = 1 << 1,
   CANCEL_BEFORE_START       = 1 << 2,
   DEFER_NETWORK_START       = 1 << 3
 };
 
 // Throttle that tracks the current throttle blocking a request.  Only one
 // can throttle any request at a time.
 class GenericResourceThrottle : public ResourceThrottle {
  public:
   // The value is used to indicate that the throttle should not provide
   // a error code when cancelling a request. net::OK is used, because this
   // is not an error code.
   static const int USE_DEFAULT_CANCEL_ERROR_CODE = net::OK;
 
   GenericResourceThrottle(int flags, int code)
       : flags_(flags),
         error_code_for_cancellation_(code) {
   }
 
-  virtual ~GenericResourceThrottle() {
+  ~GenericResourceThrottle() override {
     if (active_throttle_ == this)
       active_throttle_ = NULL;
   }
 
   // ResourceThrottle implementation:
-  virtual void WillStartRequest(bool* defer) override {
+  void WillStartRequest(bool* defer) override {
     ASSERT_EQ(NULL, active_throttle_);
     if (flags_ & DEFER_STARTING_REQUEST) {
       active_throttle_ = this;
       *defer = true;
     }
 
     if (flags_ & CANCEL_BEFORE_START) {
       if (error_code_for_cancellation_ == USE_DEFAULT_CANCEL_ERROR_CODE) {
         controller()->Cancel();
       } else {
         controller()->CancelWithError(error_code_for_cancellation_);
       }
     }
   }
 
-  virtual void WillProcessResponse(bool* defer) override {
+  void WillProcessResponse(bool* defer) override {
     ASSERT_EQ(NULL, active_throttle_);
     if (flags_ & DEFER_PROCESSING_RESPONSE) {
       active_throttle_ = this;
       *defer = true;
     }
   }
 
-  virtual void WillStartUsingNetwork(bool* defer) override {
+  void WillStartUsingNetwork(bool* defer) override {
     ASSERT_EQ(NULL, active_throttle_);
 
     if (flags_ & DEFER_NETWORK_START) {
       active_throttle_ = this;
       *defer = true;
     }
   }
 
-  virtual const char* GetNameForLogging() const override {
+  const char* GetNameForLogging() const override {
     return "GenericResourceThrottle";
   }
 
   void Resume() {
     ASSERT_TRUE(this == active_throttle_);
     active_throttle_ = NULL;
     controller()->Resume();
   }
 
   static GenericResourceThrottle* active_throttle() {
@@ skipping 31 matching lines @@
   void set_error_code_for_cancellation(int code) {
     error_code_for_cancellation_ = code;
   }
 
   void set_create_two_throttles(bool create_two_throttles) {
     create_two_throttles_ = create_two_throttles;
   }
 
   // ResourceDispatcherHostDelegate implementation:
 
-  virtual void RequestBeginning(
-      net::URLRequest* request,
-      ResourceContext* resource_context,
-      AppCacheService* appcache_service,
-      ResourceType resource_type,
-      ScopedVector<ResourceThrottle>* throttles) override {
+  void RequestBeginning(net::URLRequest* request,
+                        ResourceContext* resource_context,
+                        AppCacheService* appcache_service,
+                        ResourceType resource_type,
+                        ScopedVector<ResourceThrottle>* throttles) override {
     if (user_data_) {
       const void* key = user_data_.get();
       request->SetUserData(key, user_data_.release());
     }
 
     if (flags_ != NONE) {
       throttles->push_back(new GenericResourceThrottle(
           flags_, error_code_for_cancellation_));
       if (create_two_throttles_)
         throttles->push_back(new GenericResourceThrottle(
@@ skipping 46 matching lines @@
     filter_ = MakeForwardingFilter();
     // TODO(cbentzel): Better way to get URLRequestContext?
     net::URLRequestContext* request_context =
         browser_context_->GetResourceContext()->GetRequestContext();
     job_factory_.reset(new TestURLRequestJobFactory(this));
     request_context->set_job_factory(job_factory_.get());
     request_context->set_network_delegate(&network_delegate_);
   }
 
   // IPC::Sender implementation
-  virtual bool Send(IPC::Message* msg) override {
+  bool Send(IPC::Message* msg) override {
     accum_.AddMessage(*msg);
 
     if (send_data_received_acks_ &&
         msg->type() == ResourceMsg_DataReceived::ID) {
       GenerateDataReceivedACK(*msg);
     }
 
     if (wait_for_request_complete_loop_ &&
         msg->type() == ResourceMsg_RequestComplete::ID) {
       wait_for_request_complete_loop_->Quit();
@@ skipping 2258 matching lines @@
     } else {
       return new net::URLRequestTestJob(
           request, network_delegate,
           test_fixture_->response_headers_, test_fixture_->response_data_,
           false);
     }
   }
 }
 
 }  // namespace content