Standardize usage of virtual/override/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 189 matching lines @@
 }
 
 namespace {
 
 // A helper class that vends a callback that, when fired, destroys a
 // given SpdyStreamRequest.
 class StreamRequestDestroyingCallback : public TestCompletionCallbackBase {
  public:
   StreamRequestDestroyingCallback() {}
 
-  virtual ~StreamRequestDestroyingCallback() {}
+  ~StreamRequestDestroyingCallback() override {}
 
   void SetRequestToDestroy(scoped_ptr<SpdyStreamRequest> request) {
     request_ = request.Pass();
   }
 
   CompletionCallback MakeCallback() {
     return base::Bind(&StreamRequestDestroyingCallback::OnComplete,
                       base::Unretained(this));
   }
 
@@ skipping 2075 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() {}
+  ~SessionClosingDelegate() override {}
 
-  virtual void OnClose(int status) override {
+  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 1053 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() {}
+  ~StreamCreatingDelegate() override {}
 
-  virtual void OnClose(int status) override {
+  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 256 matching lines @@
   data.RunFor(1);
 }
 
 // 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() {}
+  ~DropReceivedDataDelegate() override {}
 
   // Drop any received data.
-  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) override {}
+  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 561 matching lines @@
   EXPECT_TRUE(data.at_write_eof());
 }
 
 // Delegate that closes a given stream after sending its body.
 class StreamClosingDelegate : public test::StreamDelegateWithBody {
  public:
   StreamClosingDelegate(const base::WeakPtr<SpdyStream>& stream,
                         base::StringPiece data)
       : StreamDelegateWithBody(stream, data) {}
 
-  virtual ~StreamClosingDelegate() {}
+  ~StreamClosingDelegate() override {}
 
   void set_stream_to_close(const base::WeakPtr<SpdyStream>& stream_to_close) {
     stream_to_close_ = stream_to_close;
   }
 
-  virtual void OnDataSent() override {
+  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