replace OVERRIDE and FINAL with override and 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 75 matching lines @@
 // 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() {}
 
   // QuicEncrypter interface.
-  virtual bool SetKey(StringPiece key) OVERRIDE { return true; }
-  virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
+  virtual bool SetKey(StringPiece key) override { return true; }
+  virtual bool SetNoncePrefix(StringPiece nonce_prefix) override {
     return true;
   }
 
   virtual bool Encrypt(StringPiece nonce,
                        StringPiece associated_data,
                        StringPiece plaintext,
-                       unsigned char* output) OVERRIDE {
+                       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 {
+                                  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; }
+  virtual size_t GetKeySize() const override { return 0; }
+  virtual size_t GetNoncePrefixSize() const override { return 0; }
 
-  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE {
+  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
     return ciphertext_size - kTagSize;
   }
 
-  virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE {
+  virtual size_t GetCiphertextSize(size_t plaintext_size) const override {
     return plaintext_size + kTagSize;
   }
 
-  virtual StringPiece GetKey() const OVERRIDE {
+  virtual StringPiece GetKey() const override {
     return StringPiece();
   }
 
-  virtual StringPiece GetNoncePrefix() const OVERRIDE {
+  virtual 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() {}
 
   // QuicDecrypter interface
-  virtual bool SetKey(StringPiece key) OVERRIDE { return true; }
-  virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
+  virtual bool SetKey(StringPiece key) override { return true; }
+  virtual 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 {
+                       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 {
+                                  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(); }
+  virtual StringPiece GetKey() const override { return StringPiece(); }
+  virtual StringPiece GetNoncePrefix() const override { return StringPiece(); }
 
  protected:
   virtual uint8 GetTag(StringPiece ciphertext) {
     return ciphertext.data()[ciphertext.size()-1];
   }
 
  private:
   enum {
     kTagSize = 12,
   };
@@ skipping 10 matching lines @@
 };
 
 // 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() {}
 
   // TaggingQuicDecrypter
-  virtual uint8 GetTag(StringPiece ciphertext) OVERRIDE {
+  virtual 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 {}
+    virtual void SetImpl() override {}
+    virtual 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 {
+  virtual const QuicClock* GetClock() const override {
     return clock_;
   }
 
-  virtual QuicRandom* GetRandomGenerator() OVERRIDE {
+  virtual QuicRandom* GetRandomGenerator() override {
     return random_generator_;
   }
 
-  virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) OVERRIDE {
+  virtual 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 {
+      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 {
+  virtual bool IsWriteBlockedDataBuffered() const override {
     return is_write_blocked_data_buffered_;
   }
 
-  virtual bool IsWriteBlocked() const OVERRIDE { return write_blocked_; }
+  virtual bool IsWriteBlocked() const override { return write_blocked_; }
 
-  virtual void SetWritable() OVERRIDE { write_blocked_ = false; }
+  virtual 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 251 matching lines @@
   }
 
   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 {
+                               StringPiece data) override {
     revived_header_ = header;
   }
 
   // Public accessor method.
   QuicPacketHeader revived_header() const {
     return revived_header_;
   }
 
  private:
   QuicPacketHeader revived_header_;
@@ skipping 3403 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