Standardize usage of virtual/override/final in net/

net/quic/test_tools/crypto_test_utils.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/quic/test_tools/crypto_test_utils.h"
 
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
@@ skipping 23 matching lines @@
 const char kServerHostname[] = "test.example.com";
 const uint16 kServerPort = 80;
 
 // CryptoFramerVisitor is a framer visitor that records handshake messages.
 class CryptoFramerVisitor : public CryptoFramerVisitorInterface {
  public:
   CryptoFramerVisitor()
       : error_(false) {
   }
 
-  virtual void OnError(CryptoFramer* framer) override { error_ = true; }
+  void OnError(CryptoFramer* framer) override { error_ = true; }
 
-  virtual void OnHandshakeMessage(
-      const CryptoHandshakeMessage& message) override {
+  void OnHandshakeMessage(const CryptoHandshakeMessage& message) override {
     messages_.push_back(message);
   }
 
   bool error() const {
     return error_;
   }
 
   const vector<CryptoHandshakeMessage>& messages() const {
     return messages_;
   }
@@ skipping 72 matching lines @@
 }
 
 // A ChannelIDSource that works in asynchronous mode unless the |callback|
 // argument to GetChannelIDKey is nullptr.
 class AsyncTestChannelIDSource : public ChannelIDSource,
                                  public CryptoTestUtils::CallbackSource {
  public:
   // Takes ownership of |sync_source|, a synchronous ChannelIDSource.
   explicit AsyncTestChannelIDSource(ChannelIDSource* sync_source)
       : sync_source_(sync_source) {}
-  virtual ~AsyncTestChannelIDSource() {}
+  ~AsyncTestChannelIDSource() override {}
 
   // ChannelIDSource implementation.
-  virtual QuicAsyncStatus GetChannelIDKey(
-      const string& hostname,
-      scoped_ptr<ChannelIDKey>* channel_id_key,
-      ChannelIDSourceCallback* callback) override {
+  QuicAsyncStatus GetChannelIDKey(const string& hostname,
+                                  scoped_ptr<ChannelIDKey>* channel_id_key,
+                                  ChannelIDSourceCallback* callback) override {
     // Synchronous mode.
     if (!callback) {
       return sync_source_->GetChannelIDKey(hostname, channel_id_key, nullptr);
     }
 
     // Asynchronous mode.
     QuicAsyncStatus status =
         sync_source_->GetChannelIDKey(hostname, &channel_id_key_, nullptr);
     if (status != QUIC_SUCCESS) {
       return QUIC_FAILURE;
     }
     callback_.reset(callback);
     return QUIC_PENDING;
   }
 
   // CallbackSource implementation.
-  virtual void RunPendingCallbacks() override {
+  void RunPendingCallbacks() override {
     if (callback_.get()) {
       callback_->Run(&channel_id_key_);
       callback_.reset();
     }
   }
 
  private:
   scoped_ptr<ChannelIDSource> sync_source_;
   scoped_ptr<ChannelIDSourceCallback> callback_;
   scoped_ptr<ChannelIDKey> channel_id_key_;
@@ skipping 172 matching lines @@
 }
 
 class MockCommonCertSets : public CommonCertSets {
  public:
   MockCommonCertSets(StringPiece cert, uint64 hash, uint32 index)
       : cert_(cert.as_string()),
         hash_(hash),
         index_(index) {
   }
 
-  virtual StringPiece GetCommonHashes() const override {
+  StringPiece GetCommonHashes() const override {
     CHECK(false) << "not implemented";
     return StringPiece();
   }
 
-  virtual StringPiece GetCert(uint64 hash, uint32 index) const override {
+  StringPiece GetCert(uint64 hash, uint32 index) const override {
     if (hash == hash_ && index == index_) {
       return cert_;
     }
     return StringPiece();
   }
 
-  virtual bool MatchCert(StringPiece cert,
-                         StringPiece common_set_hashes,
-                         uint64* out_hash,
-                         uint32* out_index) const override {
+  bool MatchCert(StringPiece cert,
+                 StringPiece common_set_hashes,
+                 uint64* out_hash,
+                 uint32* out_index) const override {
     if (cert != cert_) {
       return false;
     }
 
     if (common_set_hashes.size() % sizeof(uint64) != 0) {
       return false;
     }
     bool client_has_set = false;
     for (size_t i = 0; i < common_set_hashes.size(); i += sizeof(uint64)) {
       uint64 hash;
@@ skipping 242 matching lines @@
   scoped_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
   scoped_ptr<CryptoHandshakeMessage> parsed(
       CryptoFramer::ParseMessage(bytes->AsStringPiece()));
   CHECK(parsed.get());
 
   return *parsed;
 }
 
 }  // namespace test
 }  // namespace net