Remove unused return value from QuicAlarm::Delegate::OnAlarm. No behavior change, not protected.

net/quic/quic_connection.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 <string.h>
 #include <sys/types.h>
 
 #include <algorithm>
@@ skipping 68 matching lines @@
 bool IsInitializedIPEndPoint(const IPEndPoint& address) {
   return net::GetAddressFamily(address.address()) !=
          net::ADDRESS_FAMILY_UNSPECIFIED;
 }
 
 // An alarm that is scheduled to send an ack if a timeout occurs.
 class AckAlarm : public QuicAlarm::Delegate {
  public:
   explicit AckAlarm(QuicConnection* connection) : connection_(connection) {}
 
-  QuicTime OnAlarm() override {
+  void OnAlarm() override {
     DCHECK(connection_->ack_frame_updated());
     connection_->SendAck();
-    return QuicTime::Zero();
   }
 
  private:
   QuicConnection* connection_;
 
   DISALLOW_COPY_AND_ASSIGN(AckAlarm);
 };
 
 // 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 QuicAlarm::Delegate {
  public:
   explicit RetransmissionAlarm(QuicConnection* connection)
       : connection_(connection) {}
 
-  QuicTime OnAlarm() override {
-    connection_->OnRetransmissionTimeout();
-    return QuicTime::Zero();
-  }
+  void OnAlarm() override { connection_->OnRetransmissionTimeout(); }
 
  private:
   QuicConnection* connection_;
 
   DISALLOW_COPY_AND_ASSIGN(RetransmissionAlarm);
 };
 
 // An alarm that is scheduled when the SentPacketManager requires a delay
 // before sending packets and fires when the packet may be sent.
 class SendAlarm : public QuicAlarm::Delegate {
  public:
   explicit SendAlarm(QuicConnection* connection) : connection_(connection) {}
 
-  QuicTime OnAlarm() override {
-    connection_->WriteAndBundleAcksIfNotBlocked();
-    // Never reschedule the alarm, since CanWrite does that.
-    return QuicTime::Zero();
-  }
+  void OnAlarm() override { connection_->WriteAndBundleAcksIfNotBlocked(); }
 
  private:
   QuicConnection* connection_;
 
   DISALLOW_COPY_AND_ASSIGN(SendAlarm);
 };
 
 class TimeoutAlarm : public QuicAlarm::Delegate {
  public:
   explicit TimeoutAlarm(QuicConnection* connection) : connection_(connection) {}
 
-  QuicTime OnAlarm() override {
-    connection_->CheckForTimeout();
-    // Never reschedule the alarm, since CheckForTimeout does that.
-    return QuicTime::Zero();
-  }
+  void OnAlarm() override { connection_->CheckForTimeout(); }
 
  private:
   QuicConnection* connection_;
 
   DISALLOW_COPY_AND_ASSIGN(TimeoutAlarm);
 };
 
 class PingAlarm : public QuicAlarm::Delegate {
  public:
   explicit PingAlarm(QuicConnection* connection) : connection_(connection) {}
 
-  QuicTime OnAlarm() override {
-    connection_->OnPingTimeout();
-    return QuicTime::Zero();
-  }
+  void OnAlarm() override { connection_->OnPingTimeout(); }
 
  private:
   QuicConnection* connection_;
 
   DISALLOW_COPY_AND_ASSIGN(PingAlarm);
 };
 
 class MtuDiscoveryAlarm : public QuicAlarm::Delegate {
  public:
   explicit MtuDiscoveryAlarm(QuicConnection* connection)
       : connection_(connection) {}
 
-  QuicTime OnAlarm() override {
-    connection_->DiscoverMtu();
-    // DiscoverMtu() handles rescheduling the alarm by itself.
-    return QuicTime::Zero();
-  }
+  void OnAlarm() override { connection_->DiscoverMtu(); }
 
  private:
   QuicConnection* connection_;
 
   DISALLOW_COPY_AND_ASSIGN(MtuDiscoveryAlarm);
 };
 
 // Listens for acks of MTU discovery packets and raises the maximum packet size
 // of the connection if the probe succeeds.
 class MtuDiscoveryAckListener : public QuicAckListenerInterface {
@@ skipping 2158 matching lines @@
 }
 
 StringPiece QuicConnection::GetCurrentPacket() {
   if (current_packet_data_ == nullptr) {
     return StringPiece();
   }
   return StringPiece(current_packet_data_, last_size_);
 }
 
 }  // namespace net