Standardize usage of virtual/override/final in net/

net/quic/quic_connection_test.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/quic_connection.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "net/base/net_errors.h"
@@ skipping 72 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestReceiveAlgorithm);
 };
 
 // TaggingEncrypter appends kTagSize bytes of |tag| to the end of each message.
 class TaggingEncrypter : public QuicEncrypter {
  public:
   explicit TaggingEncrypter(uint8 tag)
       : tag_(tag) {
   }
 
-  virtual ~TaggingEncrypter() {}
+  ~TaggingEncrypter() override {}
 
   // QuicEncrypter interface.
-  virtual bool SetKey(StringPiece key) override { return true; }
-  virtual bool SetNoncePrefix(StringPiece nonce_prefix) override {
-    return true;
-  }
+  bool SetKey(StringPiece key) override { return true; }
+  bool SetNoncePrefix(StringPiece nonce_prefix) override { return true; }
 
-  virtual bool Encrypt(StringPiece nonce,
-                       StringPiece associated_data,
-                       StringPiece plaintext,
-                       unsigned char* output) override {
+  bool Encrypt(StringPiece nonce,
+               StringPiece associated_data,
+               StringPiece plaintext,
+               unsigned char* output) override {
     memcpy(output, plaintext.data(), plaintext.size());
     output += plaintext.size();
     memset(output, tag_, kTagSize);
     return true;
   }
 
-  virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number,
-                                  StringPiece associated_data,
-                                  StringPiece plaintext) override {
+  QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number,
+                          StringPiece associated_data,
+                          StringPiece plaintext) override {
     const size_t len = plaintext.size() + kTagSize;
     uint8* buffer = new uint8[len];
     Encrypt(StringPiece(), associated_data, plaintext, buffer);
     return new QuicData(reinterpret_cast<char*>(buffer), len, true);
   }
 
-  virtual size_t GetKeySize() const override { return 0; }
-  virtual size_t GetNoncePrefixSize() const override { return 0; }
+  size_t GetKeySize() const override { return 0; }
+  size_t GetNoncePrefixSize() const override { return 0; }
 
-  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
+  size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
     return ciphertext_size - kTagSize;
   }
 
-  virtual size_t GetCiphertextSize(size_t plaintext_size) const override {
+  size_t GetCiphertextSize(size_t plaintext_size) const override {
     return plaintext_size + kTagSize;
   }
 
-  virtual StringPiece GetKey() const override {
-    return StringPiece();
-  }
+  StringPiece GetKey() const override { return StringPiece(); }
 
-  virtual StringPiece GetNoncePrefix() const override {
-    return StringPiece();
-  }
+  StringPiece GetNoncePrefix() const override { return StringPiece(); }
 
  private:
   enum {
     kTagSize = 12,
   };
 
   const uint8 tag_;
 
   DISALLOW_COPY_AND_ASSIGN(TaggingEncrypter);
 };
 
 // TaggingDecrypter ensures that the final kTagSize bytes of the message all
 // have the same value and then removes them.
 class TaggingDecrypter : public QuicDecrypter {
  public:
-  virtual ~TaggingDecrypter() {}
+  ~TaggingDecrypter() override {}
 
   // QuicDecrypter interface
-  virtual bool SetKey(StringPiece key) override { return true; }
-  virtual bool SetNoncePrefix(StringPiece nonce_prefix) override {
-    return true;
-  }
+  bool SetKey(StringPiece key) override { return true; }
+  bool SetNoncePrefix(StringPiece nonce_prefix) override { return true; }
 
-  virtual bool Decrypt(StringPiece nonce,
-                       StringPiece associated_data,
-                       StringPiece ciphertext,
-                       unsigned char* output,
-                       size_t* output_length) override {
+  bool Decrypt(StringPiece nonce,
+               StringPiece associated_data,
+               StringPiece ciphertext,
+               unsigned char* output,
+               size_t* output_length) override {
     if (ciphertext.size() < kTagSize) {
       return false;
     }
     if (!CheckTag(ciphertext, GetTag(ciphertext))) {
       return false;
     }
     *output_length = ciphertext.size() - kTagSize;
     memcpy(output, ciphertext.data(), *output_length);
     return true;
   }
 
-  virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number,
-                                  StringPiece associated_data,
-                                  StringPiece ciphertext) override {
+  QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number,
+                          StringPiece associated_data,
+                          StringPiece ciphertext) override {
     if (ciphertext.size() < kTagSize) {
       return nullptr;
     }
     if (!CheckTag(ciphertext, GetTag(ciphertext))) {
       return nullptr;
     }
     const size_t len = ciphertext.size() - kTagSize;
     uint8* buf = new uint8[len];
     memcpy(buf, ciphertext.data(), len);
     return new QuicData(reinterpret_cast<char*>(buf), len,
                         true /* owns buffer */);
   }
 
-  virtual StringPiece GetKey() const override { return StringPiece(); }
-  virtual StringPiece GetNoncePrefix() const override { return StringPiece(); }
+  StringPiece GetKey() const override { return StringPiece(); }
+  StringPiece GetNoncePrefix() const override { return StringPiece(); }
 
  protected:
   virtual uint8 GetTag(StringPiece ciphertext) {
     return ciphertext.data()[ciphertext.size()-1];
   }
 
  private:
   enum {
     kTagSize = 12,
   };
 
   bool CheckTag(StringPiece ciphertext, uint8 tag) {
     for (size_t i = ciphertext.size() - kTagSize; i < ciphertext.size(); i++) {
       if (ciphertext.data()[i] != tag) {
         return false;
       }
     }
 
     return true;
   }
 };
 
 // StringTaggingDecrypter ensures that the final kTagSize bytes of the message
 // match the expected value.
 class StrictTaggingDecrypter : public TaggingDecrypter {
  public:
   explicit StrictTaggingDecrypter(uint8 tag) : tag_(tag) {}
-  virtual ~StrictTaggingDecrypter() {}
+  ~StrictTaggingDecrypter() override {}
 
   // TaggingQuicDecrypter
-  virtual uint8 GetTag(StringPiece ciphertext) override {
-    return tag_;
-  }
+  uint8 GetTag(StringPiece ciphertext) override { return tag_; }
 
  private:
   const uint8 tag_;
 };
 
 class TestConnectionHelper : public QuicConnectionHelperInterface {
  public:
   class TestAlarm : public QuicAlarm {
    public:
     explicit TestAlarm(QuicAlarm::Delegate* delegate)
         : QuicAlarm(delegate) {
     }
 
-    virtual void SetImpl() override {}
-    virtual void CancelImpl() override {}
+    void SetImpl() override {}
+    void CancelImpl() override {}
     using QuicAlarm::Fire;
   };
 
   TestConnectionHelper(MockClock* clock, MockRandom* random_generator)
       : clock_(clock),
         random_generator_(random_generator) {
     clock_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
   }
 
   // QuicConnectionHelperInterface
-  virtual const QuicClock* GetClock() const override {
-    return clock_;
-  }
+  const QuicClock* GetClock() const override { return clock_; }
 
-  virtual QuicRandom* GetRandomGenerator() override {
-    return random_generator_;
-  }
+  QuicRandom* GetRandomGenerator() override { return random_generator_; }
 
-  virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override {
+  QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override {
     return new TestAlarm(delegate);
   }
 
  private:
   MockClock* clock_;
   MockRandom* random_generator_;
 
   DISALLOW_COPY_AND_ASSIGN(TestConnectionHelper);
 };
 
 class TestPacketWriter : public QuicPacketWriter {
  public:
   explicit TestPacketWriter(QuicVersion version)
       : version_(version),
         framer_(SupportedVersions(version_)),
         last_packet_size_(0),
         write_blocked_(false),
         block_on_next_write_(false),
         is_write_blocked_data_buffered_(false),
         final_bytes_of_last_packet_(0),
         final_bytes_of_previous_packet_(0),
         use_tagging_decrypter_(false),
         packets_write_attempts_(0) {
   }
 
   // QuicPacketWriter interface
-  virtual WriteResult WritePacket(
-      const char* buffer, size_t buf_len,
-      const IPAddressNumber& self_address,
-      const IPEndPoint& peer_address) override {
+  WriteResult WritePacket(const char* buffer,
+                          size_t buf_len,
+                          const IPAddressNumber& self_address,
+                          const IPEndPoint& peer_address) override {
     QuicEncryptedPacket packet(buffer, buf_len);
     ++packets_write_attempts_;
 
     if (packet.length() >= sizeof(final_bytes_of_last_packet_)) {
       final_bytes_of_previous_packet_ = final_bytes_of_last_packet_;
       memcpy(&final_bytes_of_last_packet_, packet.data() + packet.length() - 4,
              sizeof(final_bytes_of_last_packet_));
     }
 
     if (use_tagging_decrypter_) {
       framer_.framer()->SetDecrypter(new TaggingDecrypter, ENCRYPTION_NONE);
     }
     EXPECT_TRUE(framer_.ProcessPacket(packet));
     if (block_on_next_write_) {
       write_blocked_ = true;
       block_on_next_write_ = false;
     }
     if (IsWriteBlocked()) {
       return WriteResult(WRITE_STATUS_BLOCKED, -1);
     }
     last_packet_size_ = packet.length();
     return WriteResult(WRITE_STATUS_OK, last_packet_size_);
   }
 
-  virtual bool IsWriteBlockedDataBuffered() const override {
+  bool IsWriteBlockedDataBuffered() const override {
     return is_write_blocked_data_buffered_;
   }
 
-  virtual bool IsWriteBlocked() const override { return write_blocked_; }
+  bool IsWriteBlocked() const override { return write_blocked_; }
 
-  virtual void SetWritable() override { write_blocked_ = false; }
+  void SetWritable() override { write_blocked_ = false; }
 
   void BlockOnNextWrite() { block_on_next_write_ = true; }
 
   const QuicPacketHeader& header() { return framer_.header(); }
 
   size_t frame_count() const { return framer_.num_frames(); }
 
   const vector<QuicAckFrame>& ack_frames() const {
     return framer_.ack_frames();
   }
@@ skipping 250 matching lines @@
     return static_cast<TestPacketWriter*>(QuicConnection::writer());
   }
 
   DISALLOW_COPY_AND_ASSIGN(TestConnection);
 };
 
 // Used for testing packets revived from FEC packets.
 class FecQuicConnectionDebugVisitor
     : public QuicConnectionDebugVisitor {
  public:
-  virtual void OnRevivedPacket(const QuicPacketHeader& header,
-                               StringPiece data) override {
+  void OnRevivedPacket(const QuicPacketHeader& header,
+                       StringPiece data) override {
     revived_header_ = header;
   }
 
   // Public accessor method.
   QuicPacketHeader revived_header() const {
     return revived_header_;
   }
 
  private:
   QuicPacketHeader revived_header_;
@@ skipping 3416 matching lines @@
   QuicBlockedFrame blocked;
   blocked.stream_id = 3;
   EXPECT_CALL(visitor_, OnBlockedFrames(_));
   ProcessFramePacket(QuicFrame(&blocked));
   EXPECT_TRUE(ack_alarm->IsSet());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net