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

net/tools/quic/test_tools/packet_dropping_test_writer.cc

 // Copyright 2013 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/test_tools/packet_dropping_test_writer.h"
 
 #include <limits>
 
 #include "base/rand_util.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_socket_utils.h"
 
 namespace net {
 namespace test {
 
 // An alarm that is scheduled if a blocked socket is simulated to indicate
 // it's writable again.
 class WriteUnblockedAlarm : public QuicAlarm::Delegate {
  public:
   explicit WriteUnblockedAlarm(PacketDroppingTestWriter* writer)
       : writer_(writer) {}
 
-  QuicTime OnAlarm() override {
+  void OnAlarm() override {
     DVLOG(1) << "Unblocking socket.";
     writer_->OnCanWrite();
-    return QuicTime::Zero();
   }
 
  private:
   PacketDroppingTestWriter* writer_;
 };
 
 // An alarm that is scheduled every time a new packet is to be written at a
 // later point.
 class DelayAlarm : public QuicAlarm::Delegate {
  public:
   explicit DelayAlarm(PacketDroppingTestWriter* writer) : writer_(writer) {}
 
-  QuicTime OnAlarm() override { return writer_->ReleaseOldPackets(); }
+  void OnAlarm() override {
+    QuicTime new_deadline = writer_->ReleaseOldPackets();
+    if (new_deadline.IsInitialized()) {
+      writer_->SetDelayAlarm(new_deadline);
+    }
+  }
 
  private:
   PacketDroppingTestWriter* writer_;
 };
 
 PacketDroppingTestWriter::PacketDroppingTestWriter()
     : clock_(nullptr),
       cur_buffer_size_(0),
       num_calls_to_write_(0),
       config_mutex_(),
@@ skipping 146 matching lines @@
   while (!delayed_packets_.empty()) {
     QuicTime next_send_time = delayed_packets_.front().send_time;
     if (next_send_time > clock_->Now()) {
       return next_send_time;
     }
     ReleaseNextPacket();
   }
   return QuicTime::Zero();
 }
 
+void PacketDroppingTestWriter::SetDelayAlarm(QuicTime new_deadline) {
+  delay_alarm_->Set(new_deadline);
+}
+
 void PacketDroppingTestWriter::OnCanWrite() {
   on_can_write_->OnCanWrite();
 }
 
 PacketDroppingTestWriter::DelayedWrite::DelayedWrite(
     const char* buffer,
     size_t buf_len,
     const IPAddress& self_address,
     const IPEndPoint& peer_address,
     std::unique_ptr<PerPacketOptions> options,
@@ skipping 12 matching lines @@
 // IPAddress has no move assignment operator.
 //
 // PacketDroppingTestWriter::DelayedWrite&
 // PacketDroppingTestWriter::DelayedWrite::operator=(
 //    PacketDroppingTestWriter::DelayedWrite&& other) = default;
 
 PacketDroppingTestWriter::DelayedWrite::~DelayedWrite() {}
 
 }  // namespace test
 }  // namespace net