Linux/ChromeOS Chromium style checker cleanup, net/ edition.

Automated clean up of style checker errors that were missed due to the plugin
not being executed on implementation files.

BUG=115047

Review URL: https://chromiumcodereview.appspot.com/12223022

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@180944 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 64 insertions, 56 deletions

diff --git a/net/quic/congestion_control/cubic_test.cc b/net/quic/congestion_control/cubic_test.cc
index f40a591..84f2a7b 100644
--- a/net/quic/congestion_control/cubic_test.cc
+++ b/net/quic/congestion_control/cubic_test.cc
@@ -26,7 +26,7 @@ class CubicTest : public ::testing::Test {
       : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
         hundred_ms_(QuicTime::Delta::FromMilliseconds(100)) {
   }
-  void SetUp() {
+  virtual void SetUp() {
     cubic_.reset(new CubicPeer(&clock_));
   }
   const QuicTime::Delta one_ms_;
diff --git a/net/quic/congestion_control/hybrid_slow_start_test.cc b/net/quic/congestion_control/hybrid_slow_start_test.cc
index c913694..0a9f91f 100644
--- a/net/quic/congestion_control/hybrid_slow_start_test.cc
+++ b/net/quic/congestion_control/hybrid_slow_start_test.cc
@@ -17,7 +17,7 @@ class HybridSlowStartTest : public ::testing::Test {
      : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
        rtt_(QuicTime::Delta::FromMilliseconds(60)) {
   }
-  void SetUp() {
+  virtual void SetUp() {
     slowStart_.reset(new HybridSlowStart(&clock_));
   }
   const QuicTime::Delta one_ms_;
diff --git a/net/quic/congestion_control/leaky_bucket_test.cc b/net/quic/congestion_control/leaky_bucket_test.cc
index a510200..89ab5db 100644
--- a/net/quic/congestion_control/leaky_bucket_test.cc
+++ b/net/quic/congestion_control/leaky_bucket_test.cc
@@ -13,7 +13,7 @@ namespace test {
 
 class LeakyBucketTest : public ::testing::Test {
  protected:
-  void SetUp() {
+  virtual void SetUp() {
     leaky_bucket_.reset(new LeakyBucket(&clock_, QuicBandwidth::Zero()));
   }
   MockClock clock_;
diff --git a/net/quic/congestion_control/tcp_receiver_test.cc b/net/quic/congestion_control/tcp_receiver_test.cc
index 5bb12f4..305ff75 100644
--- a/net/quic/congestion_control/tcp_receiver_test.cc
+++ b/net/quic/congestion_control/tcp_receiver_test.cc
@@ -13,7 +13,7 @@ namespace test {
 
 class QuicTcpReceiverTest : public ::testing::Test {
  protected:
-  void SetUp() {
+  virtual void SetUp() {
     receiver_.reset(new TcpReceiver());
   }
   scoped_ptr<TcpReceiver> receiver_;
diff --git a/net/quic/crypto/crypto_framer_test.cc b/net/quic/crypto/crypto_framer_test.cc
index 87c5c2a..93d7d58 100644
--- a/net/quic/crypto/crypto_framer_test.cc
+++ b/net/quic/crypto/crypto_framer_test.cc
@@ -34,12 +34,13 @@ class TestCryptoVisitor : public ::net::CryptoFramerVisitorInterface {
       : error_count_(0) {
   }
 
-  virtual void OnError(CryptoFramer* framer) {
+  virtual void OnError(CryptoFramer* framer) OVERRIDE {
     DLOG(ERROR) << "CryptoFramer Error: " << framer->error();
     ++error_count_;
   }
 
-  virtual void OnHandshakeMessage(const CryptoHandshakeMessage& message) {
+  virtual void OnHandshakeMessage(
+      const CryptoHandshakeMessage& message) OVERRIDE {
     messages_.push_back(message);
   }
 
diff --git a/net/quic/crypto/quic_random.cc b/net/quic/crypto/quic_random.cc
index 579ebec..9a67918 100644
--- a/net/quic/crypto/quic_random.cc
+++ b/net/quic/crypto/quic_random.cc
@@ -17,9 +17,10 @@ class DefaultRandom : public QuicRandom {
   static DefaultRandom* GetInstance();
 
   // QuicRandom implementation
-  virtual void RandBytes(void* data, size_t len);
-  virtual uint64 RandUint64();
-  virtual void Reseed(const void* additional_entropy, size_t entropy_len);
+  virtual void RandBytes(void* data, size_t len) OVERRIDE;
+  virtual uint64 RandUint64() OVERRIDE;
+  virtual void Reseed(const void* additional_entropy,
+                      size_t entropy_len) OVERRIDE;
 
  private:
   DefaultRandom();
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
index 1dbde23..51a9784 100644
--- a/net/quic/quic_connection_test.cc
+++ b/net/quic/quic_connection_test.cc
@@ -71,18 +71,18 @@ class TestConnectionHelper : public QuicConnectionHelperInterface {
   }
 
   // QuicConnectionHelperInterface
-  virtual void SetConnection(QuicConnection* connection) {}
+  virtual void SetConnection(QuicConnection* connection) OVERRIDE {}
 
-  virtual const QuicClock* GetClock() const {
+  virtual const QuicClock* GetClock() const OVERRIDE {
     return clock_;
   }
 
-  virtual QuicRandom* GetRandomGenerator() {
+  virtual QuicRandom* GetRandomGenerator() OVERRIDE {
     return random_generator_;
   }
 
   virtual int WritePacketToWire(const QuicEncryptedPacket& packet,
-                                int* error) {
+                                int* error) OVERRIDE {
     QuicFramer framer(QuicDecrypter::Create(kNULL),
                       QuicEncrypter::Create(kNULL));
     FramerVisitorCapturingAcks visitor;
@@ -103,28 +103,28 @@ class TestConnectionHelper : public QuicConnectionHelperInterface {
     return packet.length();
   }
 
-  virtual void SetRetransmissionAlarm(QuicTime::Delta delay) {
+  virtual void SetRetransmissionAlarm(QuicTime::Delta delay) OVERRIDE {
     retransmission_alarm_ = clock_->Now().Add(delay);
   }
 
-  virtual void SetSendAlarm(QuicTime::Delta delay) {
+  virtual void SetSendAlarm(QuicTime::Delta delay) OVERRIDE {
     send_alarm_ = clock_->Now().Add(delay);
   }
 
-  virtual void SetTimeoutAlarm(QuicTime::Delta delay) {
+  virtual void SetTimeoutAlarm(QuicTime::Delta delay) OVERRIDE {
     timeout_alarm_ = clock_->Now().Add(delay);
   }
 
-  virtual bool IsSendAlarmSet() {
+  virtual bool IsSendAlarmSet() OVERRIDE {
     return send_alarm_ > clock_->Now();
   }
 
-  virtual void UnregisterSendAlarmIfRegistered() {
+  virtual void UnregisterSendAlarmIfRegistered() OVERRIDE {
     send_alarm_ = QuicTime::Zero();
   }
 
-  virtual void SetAckAlarm(QuicTime::Delta delay) {}
-  virtual void ClearAckAlarm() {}
+  virtual void SetAckAlarm(QuicTime::Delta delay) OVERRIDE {}
+  virtual void ClearAckAlarm() OVERRIDE {}
 
   QuicTime retransmission_alarm() const {
     return retransmission_alarm_;
diff --git a/net/quic/quic_crypto_client_stream_test.cc b/net/quic/quic_crypto_client_stream_test.cc
index adbf139..be53dc6 100644
--- a/net/quic/quic_crypto_client_stream_test.cc
+++ b/net/quic/quic_crypto_client_stream_test.cc
@@ -20,7 +20,7 @@ class TestQuicVisitor : public NoOpFramerVisitor {
   TestQuicVisitor() {}
 
   // NoOpFramerVisitor
-  virtual void OnStreamFrame(const QuicStreamFrame& frame) {
+  virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
     frame_ = frame;
   }
 
@@ -38,12 +38,13 @@ class TestCryptoVisitor : public CryptoFramerVisitorInterface {
       : error_count_(0) {
   }
 
-  virtual void OnError(CryptoFramer* framer) {
+  virtual void OnError(CryptoFramer* framer) OVERRIDE {
     DLOG(ERROR) << "CryptoFramer Error: " << framer->error();
     ++error_count_;
   }
 
-  virtual void OnHandshakeMessage(const CryptoHandshakeMessage& message) {
+  virtual void OnHandshakeMessage(
+      const CryptoHandshakeMessage& message) OVERRIDE {
     messages_.push_back(message);
   }
 
@@ -61,7 +62,7 @@ class TestMockHelper : public MockHelper  {
   virtual ~TestMockHelper() {}
 
   virtual int WritePacketToWire(const QuicEncryptedPacket& packet,
-                                int* error) {
+                                int* error) OVERRIDE {
     packet_count_++;
 
     // The first packet should be ClientHello.
@@ -158,8 +159,10 @@ class TestMockSession : public MockSession {
   }
   virtual ~TestMockSession() {}
 
-  virtual QuicConsumedData WriteData(QuicStreamId id, StringPiece data,
-                                     QuicStreamOffset offset, bool fin) {
+  virtual QuicConsumedData WriteData(QuicStreamId id,
+                                     StringPiece data,
+                                     QuicStreamOffset offset,
+                                     bool fin) OVERRIDE {
     return QuicSession::WriteData(id, data, offset, fin);
   }
 };
diff --git a/net/quic/quic_crypto_stream_test.cc b/net/quic/quic_crypto_stream_test.cc
index ef1c61c..10f1657 100644
--- a/net/quic/quic_crypto_stream_test.cc
+++ b/net/quic/quic_crypto_stream_test.cc
@@ -25,7 +25,8 @@ class MockQuicCryptoStream : public QuicCryptoStream {
       : QuicCryptoStream(session) {
   }
 
-  void OnHandshakeMessage(const CryptoHandshakeMessage& message) {
+  virtual void OnHandshakeMessage(
+      const CryptoHandshakeMessage& message) OVERRIDE {
     messages_.push_back(message);
   }
 
diff --git a/net/quic/quic_framer_test.cc b/net/quic/quic_framer_test.cc
index 2b5cb38..d64df49 100644
--- a/net/quic/quic_framer_test.cc
+++ b/net/quic/quic_framer_test.cc
@@ -50,15 +50,15 @@ class TestEncrypter : public QuicEncrypter {
  public:
   virtual ~TestEncrypter() {}
   virtual QuicData* Encrypt(StringPiece associated_data,
-                            StringPiece plaintext) {
+                            StringPiece plaintext) OVERRIDE {
     associated_data_ = associated_data.as_string();
     plaintext_ = plaintext.as_string();
     return new QuicData(plaintext.data(), plaintext.length());
   }
-  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) {
+  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) OVERRIDE {
     return ciphertext_size;
   }
-  virtual size_t GetCiphertextSize(size_t plaintext_size) {
+  virtual size_t GetCiphertextSize(size_t plaintext_size) OVERRIDE {
     return plaintext_size;
   }
   string associated_data_;
@@ -69,7 +69,7 @@ class TestDecrypter : public QuicDecrypter {
  public:
   virtual ~TestDecrypter() {}
   virtual QuicData* Decrypt(StringPiece associated_data,
-                            StringPiece ciphertext) {
+                            StringPiece ciphertext) OVERRIDE {
     associated_data_ = associated_data.as_string();
     ciphertext_ = ciphertext.as_string();
     return new QuicData(ciphertext.data(), ciphertext.length());
@@ -90,71 +90,72 @@ class TestQuicVisitor : public ::net::QuicFramerVisitorInterface {
         accept_packet_(true) {
   }
 
-  ~TestQuicVisitor() {
+  virtual ~TestQuicVisitor() {
     STLDeleteElements(&stream_frames_);
     STLDeleteElements(&ack_frames_);
     STLDeleteElements(&congestion_feedback_frames_);
     STLDeleteElements(&fec_data_);
   }
 
-  virtual void OnError(QuicFramer* f) {
+  virtual void OnError(QuicFramer* f) OVERRIDE {
     DLOG(INFO) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error())
                << " (" << f->error() << ")";
     error_count_++;
   }
 
-  virtual void OnPacket() {}
+  virtual void OnPacket() OVERRIDE {}
 
-  virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) {
+  virtual void OnPublicResetPacket(
+      const QuicPublicResetPacket& packet) OVERRIDE {
     public_reset_packet_.reset(new QuicPublicResetPacket(packet));
   }
 
-  virtual void OnRevivedPacket() {
+  virtual void OnRevivedPacket() OVERRIDE {
     revived_packets_++;
   }
 
-  virtual bool OnPacketHeader(const QuicPacketHeader& header) {
+  virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
     packet_count_++;
     header_.reset(new QuicPacketHeader(header));
     return accept_packet_;
   }
 
-  virtual void OnStreamFrame(const QuicStreamFrame& frame) {
+  virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
     frame_count_++;
     stream_frames_.push_back(new QuicStreamFrame(frame));
   }
 
-  virtual void OnFecProtectedPayload(StringPiece payload) {
+  virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE {
     fec_protected_payload_ = payload.as_string();
   }
 
-  virtual void OnAckFrame(const QuicAckFrame& frame) {
+  virtual void OnAckFrame(const QuicAckFrame& frame) OVERRIDE {
     frame_count_++;
     ack_frames_.push_back(new QuicAckFrame(frame));
   }
 
   virtual void OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame) {
+      const QuicCongestionFeedbackFrame& frame) OVERRIDE {
     frame_count_++;
     congestion_feedback_frames_.push_back(
         new QuicCongestionFeedbackFrame(frame));
   }
 
-  virtual void OnFecData(const QuicFecData& fec) {
+  virtual void OnFecData(const QuicFecData& fec) OVERRIDE {
     fec_count_++;
     fec_data_.push_back(new QuicFecData(fec));
   }
 
-  virtual void OnPacketComplete() {
+  virtual void OnPacketComplete() OVERRIDE {
     complete_packets_++;
   }
 
-  virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) {
+  virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE {
     rst_stream_frame_ = frame;
   }
 
   virtual void OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) {
+      const QuicConnectionCloseFrame& frame) OVERRIDE {
     connection_close_frame_ = frame;
   }
 
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index 5cdf5cd..641a306 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -86,7 +86,7 @@ class AutoClosingStream : public QuicHttpStream {
       : QuicHttpStream(stream, use_spdy) {
   }
 
-  virtual int OnDataReceived(const char* data, int length) {
+  virtual int OnDataReceived(const char* data, int length) OVERRIDE {
     Close(false);
     return OK;
   }
diff --git a/net/quic/quic_session.cc b/net/quic/quic_session.cc
index 1c41ffd..ef0efbe3 100644
--- a/net/quic/quic_session.cc
+++ b/net/quic/quic_session.cc
@@ -28,29 +28,29 @@ class VisitorShim : public QuicConnectionVisitorInterface {
   virtual bool OnPacket(const IPEndPoint& self_address,
                         const IPEndPoint& peer_address,
                         const QuicPacketHeader& header,
-                        const vector<QuicStreamFrame>& frame) {
+                        const vector<QuicStreamFrame>& frame) OVERRIDE {
     bool accepted = session_->OnPacket(self_address, peer_address, header,
                                        frame);
     session_->PostProcessAfterData();
     return accepted;
   }
-  virtual void OnRstStream(const QuicRstStreamFrame& frame) {
+  virtual void OnRstStream(const QuicRstStreamFrame& frame) OVERRIDE {
     session_->OnRstStream(frame);
     session_->PostProcessAfterData();
   }
 
-  virtual void OnAck(AckedPackets acked_packets) {
+  virtual void OnAck(AckedPackets acked_packets) OVERRIDE {
     session_->OnAck(acked_packets);
     session_->PostProcessAfterData();
   }
 
-  virtual bool OnCanWrite() {
+  virtual bool OnCanWrite() OVERRIDE {
     bool rc = session_->OnCanWrite();
     session_->PostProcessAfterData();
     return rc;
   }
 
-  virtual void ConnectionClose(QuicErrorCode error, bool from_peer) {
+  virtual void ConnectionClose(QuicErrorCode error, bool from_peer) OVERRIDE {
     session_->ConnectionClose(error, from_peer);
     // The session will go away, so don't bother with cleanup.
   }
diff --git a/net/quic/quic_session_test.cc b/net/quic/quic_session_test.cc
index 0f2d0ac..daf904e 100644
--- a/net/quic/quic_session_test.cc
+++ b/net/quic/quic_session_test.cc
@@ -27,7 +27,8 @@ class TestCryptoStream : public QuicCryptoStream {
       : QuicCryptoStream(session) {
   }
 
-  void OnHandshakeMessage(const CryptoHandshakeMessage& message) {
+  virtual void OnHandshakeMessage(
+      const CryptoHandshakeMessage& message) OVERRIDE {
     SetHandshakeComplete(QUIC_NO_ERROR);
   }
 };
@@ -52,17 +53,17 @@ class TestSession : public QuicSession {
         crypto_stream_(this) {
   }
 
-  virtual QuicCryptoStream* GetCryptoStream() {
+  virtual QuicCryptoStream* GetCryptoStream() OVERRIDE {
     return &crypto_stream_;
   }
 
-  virtual TestStream* CreateOutgoingReliableStream() {
+  virtual TestStream* CreateOutgoingReliableStream() OVERRIDE {
     TestStream* stream = new TestStream(GetNextStreamId(), this);
     ActivateStream(stream);
     return stream;
   }
 
-  virtual TestStream* CreateIncomingReliableStream(QuicStreamId id) {
+  virtual TestStream* CreateIncomingReliableStream(QuicStreamId id) OVERRIDE {
     return new TestStream(id, this);
   }
 
diff --git a/net/quic/reliable_quic_stream_test.cc b/net/quic/reliable_quic_stream_test.cc
index 86323ac..014f6de 100644
--- a/net/quic/reliable_quic_stream_test.cc
+++ b/net/quic/reliable_quic_stream_test.cc
@@ -28,7 +28,7 @@ class QuicReliableTestStream : public ReliableQuicStream {
   QuicReliableTestStream(QuicStreamId id, QuicSession* session)
       : ReliableQuicStream(id, session) {
   }
-  virtual uint32 ProcessData(const char* data, uint32 data_len) {
+  virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
     return 0;
   }
   using ReliableQuicStream::WriteData;