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

net/quic/quic_alarm_test.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/quic/quic_alarm.h"
 
 #include "base/logging.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Return;
 using testing::Invoke;
 
 namespace net {
 namespace test {
 namespace {
 
 class MockDelegate : public QuicAlarm::Delegate {
  public:
-  MOCK_METHOD0(OnAlarm, QuicTime());
+  MOCK_METHOD0(OnAlarm, void());
 };
 
 class DestructiveDelegate : public QuicAlarm::Delegate {
  public:
   DestructiveDelegate() : alarm_(nullptr) {}
 
   void set_alarm(QuicAlarm* alarm) { alarm_ = alarm; }
 
-  QuicTime OnAlarm() override {
+  void OnAlarm() override {
     DCHECK(alarm_);
     delete alarm_;
-    return QuicTime::Zero();
   }
 
  private:
   QuicAlarm* alarm_;
 };
 
 class TestAlarm : public QuicAlarm {
  public:
   explicit TestAlarm(QuicAlarm::Delegate* delegate)
       : QuicAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate)) {}
@@ skipping 87 matching lines @@
   alarm_.Set(deadline);
   alarm_.Update(QuicTime::Zero(), QuicTime::Delta::Zero());
   EXPECT_FALSE(alarm_.IsSet());
   EXPECT_FALSE(alarm_.scheduled());
   EXPECT_EQ(QuicTime::Zero(), alarm_.deadline());
 }
 
 TEST_F(QuicAlarmTest, Fire) {
   QuicTime deadline = QuicTime::Zero().Add(QuicTime::Delta::FromSeconds(7));
   alarm_.Set(deadline);
-  EXPECT_CALL(*delegate_, OnAlarm()).WillOnce(Return(QuicTime::Zero()));
   alarm_.FireAlarm();
   EXPECT_FALSE(alarm_.IsSet());
   EXPECT_FALSE(alarm_.scheduled());
   EXPECT_EQ(QuicTime::Zero(), alarm_.deadline());
 }
 
-TEST_F(QuicAlarmTest, FireAndResetViaReturn) {
-  alarm_.Set(deadline_);
-  EXPECT_CALL(*delegate_, OnAlarm()).WillOnce(Return(deadline2_));
-  alarm_.FireAlarm();
-  EXPECT_TRUE(alarm_.IsSet());
-  EXPECT_TRUE(alarm_.scheduled());
-  EXPECT_EQ(deadline2_, alarm_.deadline());
-}
-
 TEST_F(QuicAlarmTest, FireAndResetViaSet) {
   alarm_.Set(deadline_);
   new_deadline_ = deadline2_;
   EXPECT_CALL(*delegate_, OnAlarm())
-      .WillOnce(DoAll(Invoke(this, &QuicAlarmTest::ResetAlarm),
-                      Return(QuicTime::Zero())));
+      .WillOnce(Invoke(this, &QuicAlarmTest::ResetAlarm));
   alarm_.FireAlarm();
   EXPECT_TRUE(alarm_.IsSet());
   EXPECT_TRUE(alarm_.scheduled());
   EXPECT_EQ(deadline2_, alarm_.deadline());
 }
 
 TEST_F(QuicAlarmTest, FireDestroysAlarm) {
   DestructiveDelegate* delegate(new DestructiveDelegate);
   DestructiveAlarm* alarm = new DestructiveAlarm(delegate);
   delegate->set_alarm(alarm);
   QuicTime deadline = QuicTime::Zero().Add(QuicTime::Delta::FromSeconds(7));
   alarm->Set(deadline);
   // This should not crash, even though it will destroy alarm.
   alarm->FireAlarm();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net