Add heartbeat timeout.

remoting/host/heartbeat_sender_unittest.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 "remoting/host/heartbeat_sender.h"
 
 #include <set>
 
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 23 matching lines @@
 
 namespace remoting {
 
 namespace {
 
 const char kTestBotJid[] = "remotingunittest@bot.talk.google.com";
 const char kHostId[] = "0";
 const char kTestJid[] = "User@gmail.com/chromotingABC123";
 const char kTestJidNormalized[] = "user@gmail.com/chromotingABC123";
 const char kStanzaId[] = "123";
-const int kTestInterval = 123;
-const base::TimeDelta kTestTimeout = base::TimeDelta::FromSeconds(123);
+constexpr base::TimeDelta kTestInterval = base::TimeDelta::FromSeconds(123);
+constexpr base::TimeDelta kOfflineReasonTimeout =
+    base::TimeDelta::FromSeconds(123);
 
 }  // namespace
 
 ACTION_P(AddListener, list) {
   list->insert(arg0);
 }
 ACTION_P(RemoveListener, list) {
   EXPECT_TRUE(list->find(arg0) != list->end());
   list->erase(arg0);
 }
@@ skipping 23 matching lines @@
 
   void TearDown() override {
     heartbeat_sender_.reset();
     EXPECT_TRUE(signal_strategy_listeners_.empty());
   }
 
   void ValidateHeartbeatStanza(XmlElement* stanza,
                                const char* expected_sequence_id,
                                const char* expected_host_offline_reason);
 
-  void ProcessResponseWithInterval(
-    bool is_offline_heartbeat_response,
-    int interval);
+  void ProcessResponseWithInterval(bool is_offline_heartbeat_response,
+                                   base::TimeDelta interval);
 
   base::MessageLoop message_loop_;
   MockSignalStrategy signal_strategy_;
   base::MockCallback<base::Closure> mock_heartbeat_successful_callback_;
   base::MockCallback<base::Closure> mock_unknown_host_id_error_callback_;
   std::set<SignalStrategy::Listener*> signal_strategy_listeners_;
   scoped_refptr<RsaKeyPair> key_pair_;
   std::unique_ptr<HeartbeatSender> heartbeat_sender_;
 };
 
@@ skipping 97 matching lines @@
   ValidateHeartbeatStanza(stanza2.get(),
                           base::IntToString(kExpectedSequenceId).c_str(),
                           nullptr);
 
   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED);
   base::RunLoop().RunUntilIdle();
 }
 
 void HeartbeatSenderTest::ProcessResponseWithInterval(
     bool is_offline_heartbeat_response,
-    int interval) {
+    base::TimeDelta interval) {
   std::unique_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ));
   response->AddAttr(QName(std::string(), "type"), "result");
 
   XmlElement* result = new XmlElement(
       QName(kChromotingXmlNamespace, "heartbeat-result"));
   response->AddElement(result);
 
   XmlElement* set_interval = new XmlElement(
       QName(kChromotingXmlNamespace, "set-interval"));
   result->AddElement(set_interval);
 
-  set_interval->AddText(base::IntToString(interval));
+  set_interval->AddText(base::IntToString(interval.InSeconds()));
 
   heartbeat_sender_->ProcessResponse(
       is_offline_heartbeat_response, nullptr, response.get());
 }
 
 // Verify that ProcessResponse parses set-interval result.
 TEST_F(HeartbeatSenderTest, ProcessResponseSetInterval) {
   EXPECT_CALL(mock_heartbeat_successful_callback_, Run());
 
   ProcessResponseWithInterval(false, kTestInterval);
 
-  EXPECT_EQ(kTestInterval * 1000, heartbeat_sender_->interval_ms_);
+  EXPECT_EQ(kTestInterval, heartbeat_sender_->interval_);
 }
 
 // Make sure SetHostOfflineReason sends a correct stanza.
 TEST_F(HeartbeatSenderTest, DoSetHostOfflineReason) {
   XmlElement* sent_iq = nullptr;
   base::MockCallback<base::Callback<void(bool success)>> mock_ack_callback;
 
   EXPECT_CALL(signal_strategy_, GetNextId())
       .WillOnce(Return(kStanzaId));
   EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull()))
       .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true)));
   EXPECT_CALL(signal_strategy_, GetState())
       .WillOnce(Return(SignalStrategy::DISCONNECTED))
       .WillRepeatedly(Return(SignalStrategy::CONNECTED));
   EXPECT_CALL(mock_ack_callback, Run(_)).Times(0);
 
-  heartbeat_sender_->SetHostOfflineReason("test_error", kTestTimeout,
+  heartbeat_sender_->SetHostOfflineReason("test_error", kOfflineReasonTimeout,
                                           mock_ack_callback.Get());
   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED);
   base::RunLoop().RunUntilIdle();
 
   std::unique_ptr<XmlElement> stanza(sent_iq);
   ASSERT_TRUE(stanza != nullptr);
   ValidateHeartbeatStanza(stanza.get(), "0", "test_error");
 
   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED);
   base::RunLoop().RunUntilIdle();
 }
 
 // Make sure SetHostOfflineReason triggers a callback when bot responds.
 TEST_F(HeartbeatSenderTest, ProcessHostOfflineResponses) {
   base::MockCallback<base::Callback<void(bool success)>> mock_ack_callback;
 
   EXPECT_CALL(signal_strategy_, GetNextId())
       .WillOnce(Return(kStanzaId));
   EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull()))
       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
   EXPECT_CALL(signal_strategy_, GetState())
       .WillOnce(Return(SignalStrategy::DISCONNECTED))
       .WillRepeatedly(Return(SignalStrategy::CONNECTED));
   EXPECT_CALL(mock_heartbeat_successful_callback_, Run())
       .WillRepeatedly(Return());
 
   // Callback should not run, until response to offline-reason.
   EXPECT_CALL(mock_ack_callback, Run(_)).Times(0);
 
-  heartbeat_sender_->SetHostOfflineReason("test_error", kTestTimeout,
+  heartbeat_sender_->SetHostOfflineReason("test_error", kOfflineReasonTimeout,
                                           mock_ack_callback.Get());
   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED);
   base::RunLoop().RunUntilIdle();
 
   ProcessResponseWithInterval(
       false,  // <- This is not a response to offline-reason.
       kTestInterval);
   base::RunLoop().RunUntilIdle();
 
   // Callback should run once, when we get response to offline-reason.
@@ skipping 74 matching lines @@
   ASSERT_TRUE(signature != nullptr);
   EXPECT_TRUE(heartbeat_stanza->NextNamed(signature_tag) == nullptr);
 
   scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(kTestRsaKeyPair);
   ASSERT_TRUE(key_pair.get());
   std::string expected_signature = key_pair->SignMessage(
       std::string(kTestJidNormalized) + ' ' + expected_sequence_id);
   EXPECT_EQ(expected_signature, signature->BodyText());
 }
 
+TEST_F(HeartbeatSenderTest, ResponseTimeout) {
+  XmlElement* sent_iq = nullptr;
+  EXPECT_CALL(signal_strategy_, GetNextId()).WillOnce(Return(kStanzaId));
+  EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull()))
+      .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true)));
+  EXPECT_CALL(signal_strategy_, GetState())
+      .WillRepeatedly(Return(SignalStrategy::CONNECTED));
+
+  heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED);
+  base::RunLoop().RunUntilIdle();
+
+  std::unique_ptr<XmlElement> stanza(sent_iq);
+  ASSERT_TRUE(stanza);
+
+  XmlElement* sent_iq2 = nullptr;
+  EXPECT_CALL(signal_strategy_, GetNextId()).WillOnce(Return(kStanzaId + 1));
+  EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull()))
+      .WillOnce(DoAll(SaveArg<0>(&sent_iq2), Return(true)));
+
+  heartbeat_sender_->ProcessResponse(false, nullptr, nullptr /* timeout */);
+  heartbeat_sender_->DoSendStanza();
+  base::RunLoop().RunUntilIdle();
+
+  std::unique_ptr<XmlElement> stanza2(sent_iq2);
+  ASSERT_TRUE(stanza2);
+
+  EXPECT_CALL(signal_strategy_, Disconnect());
+  heartbeat_sender_->ProcessResponse(false, nullptr, nullptr /* timeout */);
+}
+
 }  // namespace remoting