Standardize usage of virtual/override/final in net/

net/quic/test_tools/crypto_test_utils_openssl.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/quic/test_tools/crypto_test_utils.h"
 
 #include <openssl/bn.h>
 #include <openssl/ec.h>
 #include <openssl/ecdsa.h>
 #include <openssl/evp.h>
 #include <openssl/obj_mac.h>
 #include <openssl/sha.h>
 
 #include "crypto/openssl_util.h"
 #include "crypto/scoped_openssl_types.h"
 #include "crypto/secure_hash.h"
 #include "net/quic/crypto/channel_id.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
 namespace test {
 
 class TestChannelIDKey : public ChannelIDKey {
  public:
   explicit TestChannelIDKey(EVP_PKEY* ecdsa_key) : ecdsa_key_(ecdsa_key) {}
-  virtual ~TestChannelIDKey() override {}
+  ~TestChannelIDKey() override {}
 
   // ChannelIDKey implementation.
 
-  virtual bool Sign(StringPiece signed_data,
-                    string* out_signature) const override {
+  bool Sign(StringPiece signed_data, string* out_signature) const override {
     crypto::ScopedEVP_MD_CTX md_ctx(EVP_MD_CTX_create());
     if (!md_ctx ||
         EVP_DigestSignInit(md_ctx.get(), nullptr, EVP_sha256(), nullptr,
                            ecdsa_key_.get()) != 1) {
       return false;
     }
 
     EVP_DigestUpdate(md_ctx.get(), ChannelIDVerifier::kContextStr,
                      strlen(ChannelIDVerifier::kContextStr) + 1);
     EVP_DigestUpdate(md_ctx.get(), ChannelIDVerifier::kClientToServerStr,
@@ skipping 23 matching lines @@
     memset(signature.get(), 0, kSignatureLength);
     BN_bn2bin(sig.get()->r, signature.get() + 32 - BN_num_bytes(sig.get()->r));
     BN_bn2bin(sig.get()->s, signature.get() + 64 - BN_num_bytes(sig.get()->s));
 
     *out_signature = string(reinterpret_cast<char*>(signature.get()),
                             kSignatureLength);
 
     return true;
   }
 
-  virtual string SerializeKey() const override {
+  string SerializeKey() const override {
     // i2d_PublicKey will produce an ANSI X9.62 public key which, for a P-256
     // key, is 0x04 (meaning uncompressed) followed by the x and y field
     // elements as 32-byte, big-endian numbers.
     static const int kExpectedKeyLength = 65;
 
     int len = i2d_PublicKey(ecdsa_key_.get(), nullptr);
     if (len != kExpectedKeyLength) {
       return "";
     }
 
     uint8 buf[kExpectedKeyLength];
     uint8* derp = buf;
     i2d_PublicKey(ecdsa_key_.get(), &derp);
 
     return string(reinterpret_cast<char*>(buf + 1), kExpectedKeyLength - 1);
   }
 
  private:
   crypto::ScopedEVP_PKEY ecdsa_key_;
 };
 
 class TestChannelIDSource : public ChannelIDSource {
  public:
-  virtual ~TestChannelIDSource() {}
+  ~TestChannelIDSource() override {}
 
   // ChannelIDSource implementation.
 
-  virtual QuicAsyncStatus GetChannelIDKey(
+  QuicAsyncStatus GetChannelIDKey(
       const string& hostname,
       scoped_ptr<ChannelIDKey>* channel_id_key,
       ChannelIDSourceCallback* /*callback*/) override {
     channel_id_key->reset(new TestChannelIDKey(HostnameToKey(hostname)));
     return QUIC_SUCCESS;
   }
 
  private:
   static EVP_PKEY* HostnameToKey(const string& hostname) {
     // In order to generate a deterministic key for a given hostname the
@@ skipping 41 matching lines @@
 };
 
 // static
 ChannelIDSource* CryptoTestUtils::ChannelIDSourceForTesting() {
   return new TestChannelIDSource();
 }
 
 }  // namespace test
 
 }  // namespace net