Warn on missing OVERRIDE/virtual everywhere, not just in header files.

net/tools/quic/quic_epoll_connection_helper.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/tools/quic/quic_epoll_connection_helper.h"
 
 #include <errno.h>
 #include <sys/socket.h>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/tools/flip_server/epoll_server.h"
 #include "net/tools/quic/quic_socket_utils.h"
 
 namespace net {
 namespace tools {
 
 // This alarm will be scheduled any time a data-bearing packet is sent out.
 // When the alarm goes off, the connection checks to see if the oldest packets
 // have been acked, and retransmit them if they have not.
 class RetransmissionAlarm : public EpollAlarm {
  public:
   explicit RetransmissionAlarm(QuicConnection* connection)
       : connection_(connection) {
   }
 
-  virtual int64 OnAlarm() {
+  virtual int64 OnAlarm() OVERRIDE {
     EpollAlarm::OnAlarm();
     // This is safe because this code is Google3 specific, and the
     // Google3 QuicTime's epoch is the unix epoch.
     return connection_->OnRetransmissionTimeout().Subtract(
         QuicTime::Zero()).ToMicroseconds();
   }
 
  private:
   QuicConnection* connection_;
 };
 
 // An alarm that is scheduled when the sent scheduler requires a
 // a delay before sending packets and fires when the packet may be sent.
 class SendAlarm : public EpollAlarm {
  public:
   explicit SendAlarm(QuicConnection* connection)
       : connection_(connection) {
   }
 
-  virtual int64 OnAlarm() {
+  virtual int64 OnAlarm() OVERRIDE {
     EpollAlarm::OnAlarm();
     connection_->OnCanWrite();
     // Never reschedule the alarm, since OnCanWrite does that.
     return 0;
   }
 
  private:
   QuicConnection* connection_;
 };
 
 // An alarm which fires when the connection may have timed out.
 class TimeoutAlarm : public EpollAlarm {
  public:
   explicit TimeoutAlarm(QuicConnection* connection)
       : connection_(connection) {
   }
 
-  virtual int64 OnAlarm() {
+  virtual int64 OnAlarm() OVERRIDE {
     EpollAlarm::OnAlarm();
     connection_->CheckForTimeout();
     // Never reschedule the alarm, since CheckForTimeout does that.
     return 0;
   }
 
  private:
   QuicConnection* connection_;
 };
 
 // An alarm that is scheduled to send an ack if a timeout occurs.
 class AckAlarm : public EpollAlarm {
  public:
   explicit AckAlarm(QuicConnection* connection)
       : connection_(connection) {
   }
 
-  virtual int64 OnAlarm() {
+  virtual int64 OnAlarm() OVERRIDE {
     EpollAlarm::OnAlarm();
     connection_->SendAck();
     return 0;
   }
 
  private:
   QuicConnection* connection_;
 };
 
 QuicEpollConnectionHelper::QuicEpollConnectionHelper(
@@ skipping 103 matching lines @@
 bool QuicEpollConnectionHelper::IsSendAlarmSet() {
   return send_alarm_->registered();
 }
 
 void QuicEpollConnectionHelper::UnregisterSendAlarmIfRegistered() {
   send_alarm_->UnregisterIfRegistered();
 }
 
 }  // namespace tools
 }  // namespace net