replace OVERRIDE and FINAL with override and final in net/

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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 "net/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 8180 matching lines @@
 
 TEST_P(HttpNetworkTransactionTest, CancelDuringInitRequestBody) {
   class FakeUploadElementReader : public UploadElementReader {
    public:
     FakeUploadElementReader() {}
     virtual ~FakeUploadElementReader() {}
 
     const CompletionCallback& callback() const { return callback_; }
 
     // UploadElementReader overrides:
-    virtual int Init(const CompletionCallback& callback) OVERRIDE {
+    virtual int Init(const CompletionCallback& callback) override {
       callback_ = callback;
       return ERR_IO_PENDING;
     }
-    virtual uint64 GetContentLength() const OVERRIDE { return 0; }
-    virtual uint64 BytesRemaining() const OVERRIDE { return 0; }
+    virtual uint64 GetContentLength() const override { return 0; }
+    virtual uint64 BytesRemaining() const override { return 0; }
     virtual int Read(IOBuffer* buf,
                      int buf_length,
-                     const CompletionCallback& callback) OVERRIDE {
+                     const CompletionCallback& callback) override {
       return ERR_FAILED;
     }
 
    private:
     CompletionCallback callback_;
   };
 
   FakeUploadElementReader* fake_reader = new FakeUploadElementReader;
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(fake_reader);
@@ skipping 878 matching lines @@
 
 class CapturingProxyResolver : public ProxyResolver {
  public:
   CapturingProxyResolver() : ProxyResolver(false /* expects_pac_bytes */) {}
   virtual ~CapturingProxyResolver() {}
 
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE {
+                             const BoundNetLog& net_log) override {
     ProxyServer proxy_server(ProxyServer::SCHEME_HTTP,
                              HostPortPair("myproxy", 80));
     results->UseProxyServer(proxy_server);
     resolved_.push_back(url);
     return OK;
   }
 
-  virtual void CancelRequest(RequestHandle request) OVERRIDE {
+  virtual void CancelRequest(RequestHandle request) override {
     NOTREACHED();
   }
 
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
+  virtual LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() OVERRIDE {
+  virtual void CancelSetPacScript() override {
     NOTREACHED();
   }
 
   virtual int SetPacScript(const scoped_refptr<ProxyResolverScriptData>&,
-                           const CompletionCallback& /*callback*/) OVERRIDE {
+                           const CompletionCallback& /*callback*/) override {
     return OK;
   }
 
   const std::vector<GURL>& resolved() const { return resolved_; }
 
  private:
   std::vector<GURL> resolved_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingProxyResolver);
 };
@@ skipping 921 matching lines @@
 class UrlRecordingHttpAuthHandlerMock : public HttpAuthHandlerMock {
  public:
   explicit UrlRecordingHttpAuthHandlerMock(GURL* url) : url_(url) {}
 
   virtual ~UrlRecordingHttpAuthHandlerMock() {}
 
  protected:
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     const CompletionCallback& callback,
-                                    std::string* auth_token) OVERRIDE {
+                                    std::string* auth_token) override {
     *url_ = request->url;
     return HttpAuthHandlerMock::GenerateAuthTokenImpl(
         credentials, request, callback, auth_token);
   }
 
  private:
   GURL* url_;
 };
 
 TEST_P(HttpNetworkTransactionTest, SpdyAlternateProtocolThroughProxy) {
@@ skipping 1076 matching lines @@
   virtual ~OneTimeCachingHostResolver() {}
 
   RuleBasedHostResolverProc* rules() { return host_resolver_.rules(); }
 
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
                       RequestPriority priority,
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
-                      const BoundNetLog& net_log) OVERRIDE {
+                      const BoundNetLog& net_log) override {
     return host_resolver_.Resolve(
         info, priority, addresses, callback, out_req, net_log);
   }
 
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
-                               const BoundNetLog& net_log) OVERRIDE {
+                               const BoundNetLog& net_log) override {
     int rv = host_resolver_.ResolveFromCache(info, addresses, net_log);
     if (rv == OK && info.host_port_pair().Equals(host_port_))
       host_resolver_.GetHostCache()->clear();
     return rv;
   }
 
-  virtual void CancelRequest(RequestHandle req) OVERRIDE {
+  virtual void CancelRequest(RequestHandle req) override {
     host_resolver_.CancelRequest(req);
   }
 
   MockCachingHostResolver* GetMockHostResolver() {
     return &host_resolver_;
   }
 
  private:
   MockCachingHostResolver host_resolver_;
   const HostPortPair host_port_;
@@ skipping 1011 matching lines @@
                    public base::SupportsWeakPtr<FakeStream> {
  public:
   explicit FakeStream(RequestPriority priority) : priority_(priority) {}
   virtual ~FakeStream() {}
 
   RequestPriority priority() const { return priority_; }
 
   virtual int InitializeStream(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) OVERRIDE {
+                               const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
   virtual int SendRequest(const HttpRequestHeaders& request_headers,
                           HttpResponseInfo* response,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE {
+  virtual int ReadResponseHeaders(const CompletionCallback& callback) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
   virtual int ReadResponseBody(IOBuffer* buf, int buf_len,
-                               const CompletionCallback& callback) OVERRIDE {
+                               const CompletionCallback& callback) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
-  virtual void Close(bool not_reusable) OVERRIDE {}
+  virtual void Close(bool not_reusable) override {}
 
-  virtual bool IsResponseBodyComplete() const OVERRIDE {
+  virtual bool IsResponseBodyComplete() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual bool CanFindEndOfResponse() const OVERRIDE {
+  virtual bool CanFindEndOfResponse() const override {
     return false;
   }
 
-  virtual bool IsConnectionReused() const OVERRIDE {
+  virtual bool IsConnectionReused() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual void SetConnectionReused() OVERRIDE {
+  virtual void SetConnectionReused() override {
     ADD_FAILURE();
   }
 
-  virtual bool IsConnectionReusable() const OVERRIDE {
+  virtual bool IsConnectionReusable() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE {
+  virtual int64 GetTotalReceivedBytes() const override {
     ADD_FAILURE();
     return 0;
   }
 
   virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE {
+      LoadTimingInfo* load_timing_info) const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
+  virtual void GetSSLInfo(SSLInfo* ssl_info) override {
     ADD_FAILURE();
   }
 
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE {
+      SSLCertRequestInfo* cert_request_info) override {
     ADD_FAILURE();
   }
 
-  virtual bool IsSpdyHttpStream() const OVERRIDE {
+  virtual bool IsSpdyHttpStream() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual void Drain(HttpNetworkSession* session) OVERRIDE {
+  virtual void Drain(HttpNetworkSession* session) override {
     ADD_FAILURE();
   }
 
-  virtual void SetPriority(RequestPriority priority) OVERRIDE {
+  virtual void SetPriority(RequestPriority priority) override {
     priority_ = priority;
   }
 
  private:
   RequestPriority priority_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeStream);
 };
 
 // Fake HttpStreamRequest that simply records calls to SetPriority()
@@ skipping 28 matching lines @@
   base::WeakPtr<FakeStream> FinishStreamRequest() {
     FakeStream* fake_stream = new FakeStream(priority_);
     // Do this before calling OnStreamReady() as OnStreamReady() may
     // immediately delete |fake_stream|.
     base::WeakPtr<FakeStream> weak_stream = fake_stream->AsWeakPtr();
     delegate_->OnStreamReady(SSLConfig(), ProxyInfo(), fake_stream);
     return weak_stream;
   }
 
   virtual int RestartTunnelWithProxyAuth(
-      const AuthCredentials& credentials) OVERRIDE {
+      const AuthCredentials& credentials) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
-  virtual LoadState GetLoadState() const OVERRIDE {
+  virtual LoadState GetLoadState() const override {
     ADD_FAILURE();
     return LoadState();
   }
 
-  virtual void SetPriority(RequestPriority priority) OVERRIDE {
+  virtual void SetPriority(RequestPriority priority) override {
     priority_ = priority;
   }
 
-  virtual bool was_npn_negotiated() const OVERRIDE {
+  virtual bool was_npn_negotiated() const override {
     return false;
   }
 
-  virtual NextProto protocol_negotiated() const OVERRIDE {
+  virtual NextProto protocol_negotiated() const override {
     return kProtoUnknown;
   }
 
-  virtual bool using_spdy() const OVERRIDE {
+  virtual bool using_spdy() const override {
     return false;
   }
 
  private:
   RequestPriority priority_;
   HttpStreamRequest::Delegate* const delegate_;
   WebSocketHandshakeStreamBase::CreateHelper* websocket_stream_create_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeStreamRequest);
 };
 
 // Fake HttpStreamFactory that vends FakeStreamRequests.
 class FakeStreamFactory : public HttpStreamFactory {
  public:
   FakeStreamFactory() {}
   virtual ~FakeStreamFactory() {}
 
   // Returns a WeakPtr<> to the last HttpStreamRequest returned by
   // RequestStream() (which may be NULL if it was destroyed already).
   base::WeakPtr<FakeStreamRequest> last_stream_request() {
     return last_stream_request_;
   }
 
   virtual HttpStreamRequest* RequestStream(
       const HttpRequestInfo& info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
-      const BoundNetLog& net_log) OVERRIDE {
+      const BoundNetLog& net_log) override {
     FakeStreamRequest* fake_request = new FakeStreamRequest(priority, delegate);
     last_stream_request_ = fake_request->AsWeakPtr();
     return fake_request;
   }
 
   virtual HttpStreamRequest* RequestWebSocketHandshakeStream(
       const HttpRequestInfo& info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
       WebSocketHandshakeStreamBase::CreateHelper* create_helper,
-      const BoundNetLog& net_log) OVERRIDE {
+      const BoundNetLog& net_log) override {
     FakeStreamRequest* fake_request =
         new FakeStreamRequest(priority, delegate, create_helper);
     last_stream_request_ = fake_request->AsWeakPtr();
     return fake_request;
   }
 
   virtual void PreconnectStreams(int num_streams,
                                  const HttpRequestInfo& info,
                                  RequestPriority priority,
                                  const SSLConfig& server_ssl_config,
-                                 const SSLConfig& proxy_ssl_config) OVERRIDE {
+                                 const SSLConfig& proxy_ssl_config) override {
     ADD_FAILURE();
   }
 
-  virtual const HostMappingRules* GetHostMappingRules() const OVERRIDE {
+  virtual const HostMappingRules* GetHostMappingRules() const override {
     ADD_FAILURE();
     return NULL;
   }
 
  private:
   base::WeakPtr<FakeStreamRequest> last_stream_request_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeStreamFactory);
 };
 
 // TODO(yhirano): Split this class out into a net/websockets file, if it is
 // worth doing.
 class FakeWebSocketStreamCreateHelper :
       public WebSocketHandshakeStreamBase::CreateHelper {
  public:
   virtual WebSocketHandshakeStreamBase* CreateBasicStream(
       scoped_ptr<ClientSocketHandle> connection,
-      bool using_proxy) OVERRIDE {
+      bool using_proxy) override {
     NOTREACHED();
     return NULL;
   }
 
   virtual WebSocketHandshakeStreamBase* CreateSpdyStream(
       const base::WeakPtr<SpdySession>& session,
-      bool use_relative_url) OVERRIDE {
+      bool use_relative_url) override {
     NOTREACHED();
     return NULL;
   };
 
   virtual ~FakeWebSocketStreamCreateHelper() {}
 
   virtual scoped_ptr<WebSocketStream> Upgrade() {
     NOTREACHED();
     return scoped_ptr<WebSocketStream>();
   }
@@ skipping 749 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 }  // namespace net