replace OVERRIDE and FINAL with override and final in net/

net/url_request/url_request_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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 349 matching lines @@
   }
 
  private:
   void RunCallback(int response, const CompletionCallback& callback);
   void RunAuthCallback(AuthRequiredResponse response,
                        const AuthCallback& callback);
 
   // TestNetworkDelegate implementation.
   virtual int OnBeforeURLRequest(URLRequest* request,
                                  const CompletionCallback& callback,
-                                 GURL* new_url) OVERRIDE;
+                                 GURL* new_url) override;
 
   virtual int OnBeforeSendHeaders(URLRequest* request,
                                   const CompletionCallback& callback,
-                                  HttpRequestHeaders* headers) OVERRIDE;
+                                  HttpRequestHeaders* headers) override;
 
   virtual int OnHeadersReceived(
       URLRequest* request,
       const CompletionCallback& callback,
       const HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers,
-      GURL* allowed_unsafe_redirect_url) OVERRIDE;
+      GURL* allowed_unsafe_redirect_url) override;
 
   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
-      AuthCredentials* credentials) OVERRIDE;
+      AuthCredentials* credentials) override;
 
   // Resets the callbacks and |stage_blocked_for_callback_|.
   void Reset();
 
   // Checks whether we should block in |stage|. If yes, returns an error code
   // and optionally sets up callback based on |block_mode_|. If no, returns OK.
   int MaybeBlockStage(Stage stage, const CompletionCallback& callback);
 
   // Configuration parameters, can be adjusted by public methods:
   const BlockMode block_mode_;
@@ skipping 698 matching lines @@
   DeleteFile(lnk_path.c_str());
 }
 #endif  // defined(OS_WIN)
 
 // Custom URLRequestJobs for use with interceptor tests
 class RestartTestJob : public URLRequestTestJob {
  public:
   RestartTestJob(URLRequest* request, NetworkDelegate* network_delegate)
     : URLRequestTestJob(request, network_delegate, true) {}
  protected:
-  virtual void StartAsync() OVERRIDE {
+  virtual void StartAsync() override {
     this->NotifyRestartRequired();
   }
  private:
   virtual ~RestartTestJob() {}
 };
 
 class CancelTestJob : public URLRequestTestJob {
  public:
   explicit CancelTestJob(URLRequest* request, NetworkDelegate* network_delegate)
     : URLRequestTestJob(request, network_delegate, true) {}
  protected:
-  virtual void StartAsync() OVERRIDE {
+  virtual void StartAsync() override {
     request_->Cancel();
   }
  private:
   virtual ~CancelTestJob() {}
 };
 
 class CancelThenRestartTestJob : public URLRequestTestJob {
  public:
   explicit CancelThenRestartTestJob(URLRequest* request,
                                     NetworkDelegate* network_delegate)
       : URLRequestTestJob(request, network_delegate, true) {
   }
  protected:
-  virtual void StartAsync() OVERRIDE {
+  virtual void StartAsync() override {
     request_->Cancel();
     this->NotifyRestartRequired();
   }
  private:
   virtual ~CancelThenRestartTestJob() {}
 };
 
 // An Interceptor for use with interceptor tests
 class TestInterceptor : URLRequest::Interceptor {
  public:
@@ skipping 10 matching lines @@
         did_intercept_final_(false), did_cancel_final_(false) {
     URLRequest::Deprecated::RegisterRequestInterceptor(this);
   }
 
   virtual ~TestInterceptor() {
     URLRequest::Deprecated::UnregisterRequestInterceptor(this);
   }
 
   virtual URLRequestJob* MaybeIntercept(
       URLRequest* request,
-      NetworkDelegate* network_delegate) OVERRIDE {
+      NetworkDelegate* network_delegate) override {
     if (restart_main_request_) {
       restart_main_request_ = false;
       did_restart_main_ = true;
       return new RestartTestJob(request, network_delegate);
     }
     if (cancel_main_request_) {
       cancel_main_request_ = false;
       did_cancel_main_ = true;
       return new CancelTestJob(request, network_delegate);
     }
@@ skipping 17 matching lines @@
                                                     main_headers_,
                                                     main_data_,
                                                     true);
     job->set_load_timing_info(main_request_load_timing_info_);
     return job;
   }
 
   virtual URLRequestJob* MaybeInterceptRedirect(
       URLRequest* request,
       NetworkDelegate* network_delegate,
-      const GURL& location) OVERRIDE {
+      const GURL& location) override {
     if (cancel_redirect_request_) {
       cancel_redirect_request_ = false;
       did_cancel_redirect_ = true;
       return new CancelTestJob(request, network_delegate);
     }
     if (!intercept_redirect_)
       return NULL;
     intercept_redirect_ = false;
     did_intercept_redirect_ = true;
     return new URLRequestTestJob(request,
                                  network_delegate,
                                  redirect_headers_,
                                  redirect_data_,
                                  true);
   }
 
   virtual URLRequestJob* MaybeInterceptResponse(
-      URLRequest* request, NetworkDelegate* network_delegate) OVERRIDE {
+      URLRequest* request, NetworkDelegate* network_delegate) override {
     if (cancel_final_request_) {
       cancel_final_request_ = false;
       did_cancel_final_ = true;
       return new CancelTestJob(request, network_delegate);
     }
     if (!intercept_final_response_)
       return NULL;
     intercept_final_response_ = false;
     did_intercept_final_ = true;
     return new URLRequestTestJob(request,
@@ skipping 1165 matching lines @@
   explicit FixedDateNetworkDelegate(const std::string& fixed_date)
       : fixed_date_(fixed_date) {}
   virtual ~FixedDateNetworkDelegate() {}
 
   // NetworkDelegate implementation
   virtual int OnHeadersReceived(
       URLRequest* request,
       const CompletionCallback& callback,
       const HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers,
-      GURL* allowed_unsafe_redirect_url) OVERRIDE;
+      GURL* allowed_unsafe_redirect_url) override;
 
  private:
   std::string fixed_date_;
 
   DISALLOW_COPY_AND_ASSIGN(FixedDateNetworkDelegate);
 };
 
 int FixedDateNetworkDelegate::OnHeadersReceived(
     URLRequest* request,
     const CompletionCallback& callback,
@@ skipping 1571 matching lines @@
 // before headers are sent, when headers are read, and when auth information
 // is requested.  Uses AsyncDelegateLogger.
 class AsyncLoggingNetworkDelegate : public TestNetworkDelegate {
  public:
   AsyncLoggingNetworkDelegate() {}
   virtual ~AsyncLoggingNetworkDelegate() {}
 
   // NetworkDelegate implementation.
   virtual int OnBeforeURLRequest(URLRequest* request,
                                  const CompletionCallback& callback,
-                                 GURL* new_url) OVERRIDE {
+                                 GURL* new_url) override {
     TestNetworkDelegate::OnBeforeURLRequest(request, callback, new_url);
     return RunCallbackAsynchronously(request, callback);
   }
 
   virtual int OnBeforeSendHeaders(URLRequest* request,
                                   const CompletionCallback& callback,
-                                  HttpRequestHeaders* headers) OVERRIDE {
+                                  HttpRequestHeaders* headers) override {
     TestNetworkDelegate::OnBeforeSendHeaders(request, callback, headers);
     return RunCallbackAsynchronously(request, callback);
   }
 
   virtual int OnHeadersReceived(
       URLRequest* request,
       const CompletionCallback& callback,
       const HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers,
-      GURL* allowed_unsafe_redirect_url) OVERRIDE {
+      GURL* allowed_unsafe_redirect_url) override {
     TestNetworkDelegate::OnHeadersReceived(request,
                                            callback,
                                            original_response_headers,
                                            override_response_headers,
                                            allowed_unsafe_redirect_url);
     return RunCallbackAsynchronously(request, callback);
   }
 
   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
-      AuthCredentials* credentials) OVERRIDE {
+      AuthCredentials* credentials) override {
     AsyncDelegateLogger::Run(
         request,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         base::Bind(&AsyncLoggingNetworkDelegate::SetAuthAndResume,
                    callback, credentials));
     return AUTH_REQUIRED_RESPONSE_IO_PENDING;
   }
 
@@ skipping 41 matching lines @@
     else if (cancel_stage == CANCEL_ON_RESPONSE_STARTED)
       set_cancel_in_response_started(true);
     else if (cancel_stage == CANCEL_ON_READ_COMPLETED)
       set_cancel_in_received_data(true);
   }
   virtual ~AsyncLoggingUrlRequestDelegate() {}
 
   // URLRequest::Delegate implementation:
   void virtual OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE {
+                                  bool* defer_redirect) override {
     *defer_redirect = true;
     AsyncDelegateLogger::Run(
         request,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         base::Bind(
             &AsyncLoggingUrlRequestDelegate::OnReceivedRedirectLoggingComplete,
             base::Unretained(this), request, redirect_info));
   }
 
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE {
+  virtual void OnResponseStarted(URLRequest* request) override {
     AsyncDelegateLogger::Run(
       request,
       LOAD_STATE_WAITING_FOR_DELEGATE,
       LOAD_STATE_WAITING_FOR_DELEGATE,
       LOAD_STATE_WAITING_FOR_DELEGATE,
       base::Bind(
           &AsyncLoggingUrlRequestDelegate::OnResponseStartedLoggingComplete,
           base::Unretained(this), request));
   }
 
   virtual void OnReadCompleted(URLRequest* request,
-                               int bytes_read) OVERRIDE {
+                               int bytes_read) override {
     AsyncDelegateLogger::Run(
         request,
         LOAD_STATE_IDLE,
         LOAD_STATE_IDLE,
         LOAD_STATE_IDLE,
         base::Bind(
             &AsyncLoggingUrlRequestDelegate::AfterReadCompletedLoggingComplete,
             base::Unretained(this), request, bytes_read));
   }
 
@@ skipping 447 matching lines @@
 }
 
 namespace {
 
 const char kExtraHeader[] = "Allow-Snafu";
 const char kExtraValue[] = "fubar";
 
 class RedirectWithAdditionalHeadersDelegate : public TestDelegate {
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE {
+                                  bool* defer_redirect) override {
     TestDelegate::OnReceivedRedirect(request, redirect_info, defer_redirect);
     request->SetExtraRequestHeaderByName(kExtraHeader, kExtraValue, false);
   }
 };
 
 }  // namespace
 
 TEST_F(URLRequestTestHTTP, RedirectWithAdditionalHeadersTest) {
   ASSERT_TRUE(test_server_.Start());
 
@@ skipping 16 matching lines @@
   EXPECT_EQ(kExtraValue, d.data_received());
 }
 
 namespace {
 
 const char kExtraHeaderToRemove[] = "To-Be-Removed";
 
 class RedirectWithHeaderRemovalDelegate : public TestDelegate {
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE {
+                                  bool* defer_redirect) override {
     TestDelegate::OnReceivedRedirect(request, redirect_info, defer_redirect);
     request->RemoveRequestHeaderByName(kExtraHeaderToRemove);
   }
 };
 
 }  // namespace
 
 TEST_F(URLRequestTestHTTP, RedirectWithHeaderRemovalTest) {
   ASSERT_TRUE(test_server_.Start());
 
@@ skipping 2175 matching lines @@
 }
 
 namespace {
 
 class SSLClientAuthTestDelegate : public TestDelegate {
  public:
   SSLClientAuthTestDelegate() : on_certificate_requested_count_(0) {
   }
   virtual void OnCertificateRequested(
       URLRequest* request,
-      SSLCertRequestInfo* cert_request_info) OVERRIDE {
+      SSLCertRequestInfo* cert_request_info) override {
     on_certificate_requested_count_++;
     base::MessageLoop::current()->Quit();
   }
   int on_certificate_requested_count() {
     return on_certificate_requested_count_;
   }
  private:
   int on_certificate_requested_count_;
 };
 
@@ skipping 499 matching lines @@
  public:
   TestSSLConfigService(bool ev_enabled,
                        bool online_rev_checking,
                        bool rev_checking_required_local_anchors)
       : ev_enabled_(ev_enabled),
         online_rev_checking_(online_rev_checking),
         rev_checking_required_local_anchors_(
             rev_checking_required_local_anchors) {}
 
   // SSLConfigService:
-  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {
+  virtual void GetSSLConfig(SSLConfig* config) override {
     *config = SSLConfig();
     config->rev_checking_enabled = online_rev_checking_;
     config->verify_ev_cert = ev_enabled_;
     config->rev_checking_required_local_anchors =
         rev_checking_required_local_anchors_;
   }
 
  protected:
   virtual ~TestSSLConfigService() {}
 
@@ skipping 25 matching lines @@
 class HTTPSOCSPTest : public HTTPSRequestTest {
  public:
   HTTPSOCSPTest()
       : context_(true),
         ev_test_policy_(
             new ScopedTestEVPolicy(EVRootCAMetadata::GetInstance(),
                                    kOCSPTestCertFingerprint,
                                    kOCSPTestCertPolicy)) {
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     SetupContext(&context_);
     context_.Init();
 
     scoped_refptr<X509Certificate> root_cert =
         ImportCertFromFile(GetTestCertsDirectory(), "ocsp-test-root.pem");
     CHECK_NE(static_cast<X509Certificate*>(NULL), root_cert.get());
     test_root_.reset(new ScopedTestRoot(root_cert.get()));
 
 #if defined(USE_NSS) || defined(OS_IOS)
     SetURLRequestContextForNSSHttpIO(&context_);
@@ skipping 160 matching lines @@
   EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(),
             cert_status & CERT_STATUS_ALL_ERRORS);
 
   // Without a positive OCSP response, we shouldn't show the EV status.
   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
   EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
 }
 
 class HTTPSHardFailTest : public HTTPSOCSPTest {
  protected:
-  virtual void SetupContext(URLRequestContext* context) OVERRIDE {
+  virtual void SetupContext(URLRequestContext* context) override {
     context->set_ssl_config_service(
         new TestSSLConfigService(false /* check for EV */,
                                  false /* online revocation checking */,
                                  true /* require rev. checking for local
                                          anchors */));
   }
 };
 
 
 TEST_F(HTTPSHardFailTest, FailsOnOCSPInvalid) {
@@ skipping 17 matching lines @@
 
   EXPECT_EQ(CERT_STATUS_REVOKED,
             cert_status & CERT_STATUS_REVOKED);
 
   // Without a positive OCSP response, we shouldn't show the EV status.
   EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
 }
 
 class HTTPSEVCRLSetTest : public HTTPSOCSPTest {
  protected:
-  virtual void SetupContext(URLRequestContext* context) OVERRIDE {
+  virtual void SetupContext(URLRequestContext* context) override {
     context->set_ssl_config_service(
         new TestSSLConfigService(true /* check for EV */,
                                  false /* online revocation checking */,
                                  false /* require rev. checking for local
                                           anchors */));
   }
 };
 
 TEST_F(HTTPSEVCRLSetTest, MissingCRLSetAndInvalidOCSP) {
   if (!SystemSupportsOCSP()) {
@@ skipping 164 matching lines @@
   DoConnection(ssl_options, &cert_status);
 
   EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
 
   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
   EXPECT_FALSE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
 }
 
 class HTTPSCRLSetTest : public HTTPSOCSPTest {
  protected:
-  virtual void SetupContext(URLRequestContext* context) OVERRIDE {
+  virtual void SetupContext(URLRequestContext* context) override {
     context->set_ssl_config_service(
         new TestSSLConfigService(false /* check for EV */,
                                  false /* online revocation checking */,
                                  false /* require rev. checking for local
                                           anchors */));
   }
 };
 
 TEST_F(HTTPSCRLSetTest, ExpiredCRLSet) {
   SpawnedTestServer::SSLOptions ssl_options(
@@ skipping 382 matching lines @@
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
   }
 }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 }  // namespace net