replace OVERRIDE and FINAL with override and final in net/

net/spdy/spdy_session_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 "net/spdy/spdy_session.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 103 matching lines @@
 
   virtual ~SpdySessionTest() {
     // Important to restore the per-pool limit first, since the pool limit must
     // always be greater than group limit, and the tests reduce both limits.
     ClientSocketPoolManager::set_max_sockets_per_pool(
         HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_pool_sockets_);
     ClientSocketPoolManager::set_max_sockets_per_group(
         HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_group_sockets_);
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     g_time_delta = base::TimeDelta();
   }
 
   void CreateDeterministicNetworkSession() {
     http_session_ =
         SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
     spdy_session_pool_ = http_session_->spdy_session_pool();
   }
 
   void CreateNetworkSession() {
@@ skipping 2163 matching lines @@
 // Delegate that closes a given session when the stream is closed.
 class SessionClosingDelegate : public test::StreamDelegateDoNothing {
  public:
   SessionClosingDelegate(const base::WeakPtr<SpdyStream>& stream,
                          const base::WeakPtr<SpdySession>& session_to_close)
       : StreamDelegateDoNothing(stream),
         session_to_close_(session_to_close) {}
 
   virtual ~SessionClosingDelegate() {}
 
-  virtual void OnClose(int status) OVERRIDE {
+  virtual void OnClose(int status) override {
     session_to_close_->CloseSessionOnError(ERR_SPDY_PROTOCOL_ERROR, "Error");
   }
 
  private:
   base::WeakPtr<SpdySession> session_to_close_;
 };
 
 // Close an activated stream that closes its session. Nothing should
 // blow up. This is a regression test for http://crbug.com/263691 .
 TEST_P(SpdySessionTest, CloseActivatedStreamThatClosesSession) {
@@ skipping 1055 matching lines @@
 // Delegate that creates another stream when its stream is closed.
 class StreamCreatingDelegate : public test::StreamDelegateDoNothing {
  public:
   StreamCreatingDelegate(const base::WeakPtr<SpdyStream>& stream,
                          const base::WeakPtr<SpdySession>& session)
       : StreamDelegateDoNothing(stream),
         session_(session) {}
 
   virtual ~StreamCreatingDelegate() {}
 
-  virtual void OnClose(int status) OVERRIDE {
+  virtual void OnClose(int status) override {
     GURL url(kDefaultURL);
     ignore_result(
         CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
                                   session_, url, MEDIUM, BoundNetLog()));
   }
 
  private:
   const base::WeakPtr<SpdySession> session_;
 };
 
@@ skipping 259 matching lines @@
 // A delegate that drops any received data.
 class DropReceivedDataDelegate : public test::StreamDelegateSendImmediate {
  public:
   DropReceivedDataDelegate(const base::WeakPtr<SpdyStream>& stream,
                            base::StringPiece data)
       : StreamDelegateSendImmediate(stream, data) {}
 
   virtual ~DropReceivedDataDelegate() {}
 
   // Drop any received data.
-  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) OVERRIDE {}
+  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) override {}
 };
 
 // Send data back and forth but use a delegate that drops its received
 // data. The receive window should still increase to its original
 // value, i.e. we shouldn't "leak" receive window bytes.
 TEST_P(SpdySessionTest, SessionFlowControlNoReceiveLeaks) {
   if (GetParam() < kProtoSPDY31)
     return;
 
   const char kStreamUrl[] = "http://www.google.com/";
@@ skipping 567 matching lines @@
   StreamClosingDelegate(const base::WeakPtr<SpdyStream>& stream,
                         base::StringPiece data)
       : StreamDelegateWithBody(stream, data) {}
 
   virtual ~StreamClosingDelegate() {}
 
   void set_stream_to_close(const base::WeakPtr<SpdyStream>& stream_to_close) {
     stream_to_close_ = stream_to_close;
   }
 
-  virtual void OnDataSent() OVERRIDE {
+  virtual void OnDataSent() override {
     test::StreamDelegateWithBody::OnDataSent();
     if (stream_to_close_.get()) {
       stream_to_close_->Close();
       EXPECT_EQ(NULL, stream_to_close_.get());
     }
   }
 
  private:
   base::WeakPtr<SpdyStream> stream_to_close_;
 };
@@ skipping 872 matching lines @@
   ssl_info.cert = ImportCertFromFile(GetTestCertsDirectory(),
                                      "spdy_pooling.pem");
   ssl_info.is_issued_by_known_root = true;
   ssl_info.public_key_hashes.push_back(test::GetTestHashValue(primary_pin));
 
   EXPECT_TRUE(SpdySession::CanPool(
       &tss, ssl_info, "www.example.org", "mail.example.org"));
 }
 
 }  // namespace net