replace OVERRIDE and FINAL with override and final in net/

net/url_request/url_request_test_util.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
 #define NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
 
 #include <stdlib.h>
 
 #include <map>
@@ skipping 90 matching lines @@
   // |network_task_runner| must not be NULL.
   explicit TestURLRequestContextGetter(
       const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner);
 
   // Use to pass a pre-initialized |context|.
   TestURLRequestContextGetter(
       const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner,
       scoped_ptr<TestURLRequestContext> context);
 
   // URLRequestContextGetter implementation.
-  virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE;
+  virtual TestURLRequestContext* GetURLRequestContext() override;
   virtual scoped_refptr<base::SingleThreadTaskRunner>
-      GetNetworkTaskRunner() const OVERRIDE;
+      GetNetworkTaskRunner() const override;
 
  protected:
   virtual ~TestURLRequestContextGetter();
 
  private:
   const scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
   scoped_ptr<TestURLRequestContext> context_;
 };
 
 //-----------------------------------------------------------------------------
@@ skipping 40 matching lines @@
   bool auth_required_called() const { return auth_required_; }
   bool have_full_request_headers() const { return have_full_request_headers_; }
   const HttpRequestHeaders& full_request_headers() const {
     return full_request_headers_;
   }
   void ClearFullRequestHeaders();
 
   // URLRequest::Delegate:
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE;
-  virtual void OnBeforeNetworkStart(URLRequest* request, bool* defer) OVERRIDE;
+                                  bool* defer_redirect) override;
+  virtual void OnBeforeNetworkStart(URLRequest* request, bool* defer) override;
   virtual void OnAuthRequired(URLRequest* request,
-                              AuthChallengeInfo* auth_info) OVERRIDE;
+                              AuthChallengeInfo* auth_info) override;
   // NOTE: |fatal| causes |certificate_errors_are_fatal_| to be set to true.
   // (Unit tests use this as a post-condition.) But for policy, this method
   // consults |allow_certificate_errors_|.
   virtual void OnSSLCertificateError(URLRequest* request,
                                      const SSLInfo& ssl_info,
-                                     bool fatal) OVERRIDE;
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+                                     bool fatal) override;
+  virtual void OnResponseStarted(URLRequest* request) override;
   virtual void OnReadCompleted(URLRequest* request,
-                               int bytes_read) OVERRIDE;
+                               int bytes_read) override;
 
  private:
   static const int kBufferSize = 4096;
 
   virtual void OnResponseCompleted(URLRequest* request);
 
   // options for controlling behavior
   bool cancel_in_rr_;
   bool cancel_in_rs_;
   bool cancel_in_rd_;
@@ skipping 82 matching lines @@
 
   // Last observed proxy in proxy header sent callback.
   HostPortPair last_observed_proxy() {
     return last_observed_proxy_;
   }
 
  protected:
   // NetworkDelegate:
   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 void OnBeforeSendProxyHeaders(
       net::URLRequest* request,
       const net::ProxyInfo& proxy_info,
-      net::HttpRequestHeaders* headers) OVERRIDE;
+      net::HttpRequestHeaders* headers) override;
   virtual void OnSendHeaders(URLRequest* request,
-                             const HttpRequestHeaders& headers) OVERRIDE;
+                             const 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 void OnBeforeRedirect(URLRequest* request,
-                                const GURL& new_location) OVERRIDE;
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+                                const GURL& new_location) override;
+  virtual void OnResponseStarted(URLRequest* request) override;
   virtual void OnRawBytesRead(const URLRequest& request,
-                              int bytes_read) OVERRIDE;
-  virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE;
-  virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE;
+                              int bytes_read) override;
+  virtual void OnCompleted(URLRequest* request, bool started) override;
+  virtual void OnURLRequestDestroyed(URLRequest* request) override;
   virtual void OnPACScriptError(int line_number,
-                                const base::string16& error) OVERRIDE;
+                                const base::string16& error) override;
   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
-      AuthCredentials* credentials) OVERRIDE;
+      AuthCredentials* credentials) override;
   virtual bool OnCanGetCookies(const URLRequest& request,
-                               const CookieList& cookie_list) OVERRIDE;
+                               const CookieList& cookie_list) override;
   virtual bool OnCanSetCookie(const URLRequest& request,
                               const std::string& cookie_line,
-                              CookieOptions* options) OVERRIDE;
+                              CookieOptions* options) override;
   virtual bool OnCanAccessFile(const URLRequest& request,
-                               const base::FilePath& path) const OVERRIDE;
+                               const base::FilePath& path) const override;
   virtual bool OnCanThrottleRequest(
-      const URLRequest& request) const OVERRIDE;
+      const URLRequest& request) const override;
   virtual int OnBeforeSocketStreamConnect(
       SocketStream* stream,
-      const CompletionCallback& callback) OVERRIDE;
+      const CompletionCallback& callback) override;
   virtual bool OnCancelURLRequestWithPolicyViolatingReferrerHeader(
       const URLRequest& request,
       const GURL& target_url,
-      const GURL& referrer_url) const OVERRIDE;
+      const GURL& referrer_url) const override;
 
   void InitRequestStatesIfNew(int request_id);
 
   GURL redirect_on_headers_received_url_;
   // URL marked as safe for redirection at the onHeadersReceived stage.
   GURL allowed_unsafe_redirect_url_;
 
   int last_error_;
   int error_count_;
   int created_requests_;
@@ skipping 56 matching lines @@
 
 //-----------------------------------------------------------------------------
 
 // A simple ProtocolHandler that returns a pre-built URLRequestJob only once.
 class TestJobInterceptor : public URLRequestJobFactory::ProtocolHandler {
  public:
   TestJobInterceptor();
 
   virtual URLRequestJob* MaybeCreateJob(
       URLRequest* request,
-      NetworkDelegate* network_delegate) const OVERRIDE;
+      NetworkDelegate* network_delegate) const override;
   void set_main_intercept_job(URLRequestJob* job);
 
  private:
   mutable URLRequestJob* main_intercept_job_;
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_