replace OVERRIDE and FINAL with override and final in net/

net/quic/test_tools/simple_quic_framer.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/simple_quic_framer.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 
 using base::StringPiece;
 using std::string;
 using std::vector;
 
 namespace net {
 namespace test {
 
 class SimpleFramerVisitor : public QuicFramerVisitorInterface {
  public:
   SimpleFramerVisitor()
       : error_(QUIC_NO_ERROR) {
   }
 
-  virtual ~SimpleFramerVisitor() OVERRIDE {
+  virtual ~SimpleFramerVisitor() override {
     STLDeleteElements(&stream_data_);
   }
 
-  virtual void OnError(QuicFramer* framer) OVERRIDE {
+  virtual void OnError(QuicFramer* framer) override {
     error_ = framer->error();
   }
 
-  virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
+  virtual bool OnProtocolVersionMismatch(QuicVersion version) override {
     return false;
   }
 
-  virtual void OnPacket() OVERRIDE {}
+  virtual void OnPacket() override {}
   virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& packet) OVERRIDE {
+      const QuicPublicResetPacket& packet) override {
     public_reset_packet_.reset(new QuicPublicResetPacket(packet));
   }
   virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) OVERRIDE {
+      const QuicVersionNegotiationPacket& packet) override {
     version_negotiation_packet_.reset(
         new QuicVersionNegotiationPacket(packet));
   }
-  virtual void OnRevivedPacket() OVERRIDE {}
+  virtual void OnRevivedPacket() override {}
 
   virtual bool OnUnauthenticatedPublicHeader(
-      const QuicPacketPublicHeader& header) OVERRIDE {
+      const QuicPacketPublicHeader& header) override {
     return true;
   }
   virtual bool OnUnauthenticatedHeader(
-      const QuicPacketHeader& header) OVERRIDE {
+      const QuicPacketHeader& header) override {
     return true;
   }
-  virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {}
-  virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
+  virtual void OnDecryptedPacket(EncryptionLevel level) override {}
+  virtual bool OnPacketHeader(const QuicPacketHeader& header) override {
     has_header_ = true;
     header_ = header;
     return true;
   }
 
-  virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE {}
+  virtual void OnFecProtectedPayload(StringPiece payload) override {}
 
-  virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
+  virtual bool OnStreamFrame(const QuicStreamFrame& frame) override {
     // Save a copy of the data so it is valid after the packet is processed.
     stream_data_.push_back(frame.GetDataAsString());
     QuicStreamFrame stream_frame(frame);
     // Make sure that the stream frame points to this data.
     stream_frame.data.Clear();
     stream_frame.data.Append(const_cast<char*>(stream_data_.back()->data()),
                              stream_data_.back()->size());
     stream_frames_.push_back(stream_frame);
     return true;
   }
 
-  virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE {
+  virtual bool OnAckFrame(const QuicAckFrame& frame) override {
     ack_frames_.push_back(frame);
     return true;
   }
 
   virtual bool OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame) OVERRIDE {
+      const QuicCongestionFeedbackFrame& frame) override {
     feedback_frames_.push_back(frame);
     return true;
   }
 
-  virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE {
+  virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
     stop_waiting_frames_.push_back(frame);
     return true;
   }
 
-  virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE {
+  virtual bool OnPingFrame(const QuicPingFrame& frame) override {
     ping_frames_.push_back(frame);
     return true;
   }
 
-  virtual void OnFecData(const QuicFecData& fec) OVERRIDE {
+  virtual void OnFecData(const QuicFecData& fec) override {
     fec_data_ = fec;
     fec_redundancy_ = fec_data_.redundancy.as_string();
     fec_data_.redundancy = fec_redundancy_;
   }
 
-  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE {
+  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
     rst_stream_frames_.push_back(frame);
     return true;
   }
 
   virtual bool OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) OVERRIDE {
+      const QuicConnectionCloseFrame& frame) override {
     connection_close_frames_.push_back(frame);
     return true;
   }
 
-  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE {
+  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override {
     goaway_frames_.push_back(frame);
     return true;
   }
 
   virtual bool OnWindowUpdateFrame(
-      const QuicWindowUpdateFrame& frame) OVERRIDE {
+      const QuicWindowUpdateFrame& frame) override {
     window_update_frames_.push_back(frame);
     return true;
   }
 
-  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE {
+  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
     blocked_frames_.push_back(frame);
     return true;
   }
 
-  virtual void OnPacketComplete() OVERRIDE {}
+  virtual void OnPacketComplete() override {}
 
   const QuicPacketHeader& header() const { return header_; }
   const vector<QuicAckFrame>& ack_frames() const { return ack_frames_; }
   const vector<QuicConnectionCloseFrame>& connection_close_frames() const {
     return connection_close_frames_;
   }
   const vector<QuicCongestionFeedbackFrame>& feedback_frames() const {
     return feedback_frames_;
   }
   const vector<QuicGoAwayFrame>& goaway_frames() const {
@@ skipping 135 matching lines @@
   return visitor_->goaway_frames();
 }
 
 const vector<QuicConnectionCloseFrame>&
 SimpleQuicFramer::connection_close_frames() const {
   return visitor_->connection_close_frames();
 }
 
 }  // namespace test
 }  // namespace net