OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "remoting/host/heartbeat_sender.h" | 5 #include "remoting/host/heartbeat_sender.h" |
6 | 6 |
7 #include <set> | 7 #include <set> |
8 | 8 |
9 #include "base/memory/ref_counted.h" | 9 #include "base/memory/ref_counted.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
100 void ProcessResponseWithInterval( | 100 void ProcessResponseWithInterval( |
101 bool is_offline_heartbeat_response, | 101 bool is_offline_heartbeat_response, |
102 int interval); | 102 int interval); |
103 | 103 |
104 base::MessageLoop message_loop_; | 104 base::MessageLoop message_loop_; |
105 MockSignalStrategy signal_strategy_; | 105 MockSignalStrategy signal_strategy_; |
106 MockClosure mock_heartbeat_successful_callback_; | 106 MockClosure mock_heartbeat_successful_callback_; |
107 MockClosure mock_unknown_host_id_error_callback_; | 107 MockClosure mock_unknown_host_id_error_callback_; |
108 std::set<SignalStrategy::Listener*> signal_strategy_listeners_; | 108 std::set<SignalStrategy::Listener*> signal_strategy_listeners_; |
109 scoped_refptr<RsaKeyPair> key_pair_; | 109 scoped_refptr<RsaKeyPair> key_pair_; |
110 scoped_ptr<HeartbeatSender> heartbeat_sender_; | 110 std::unique_ptr<HeartbeatSender> heartbeat_sender_; |
111 }; | 111 }; |
112 | 112 |
113 // Call Start() followed by Stop(), and make sure a valid heartbeat is sent. | 113 // Call Start() followed by Stop(), and make sure a valid heartbeat is sent. |
114 TEST_F(HeartbeatSenderTest, DoSendStanza) { | 114 TEST_F(HeartbeatSenderTest, DoSendStanza) { |
115 XmlElement* sent_iq = nullptr; | 115 XmlElement* sent_iq = nullptr; |
116 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 116 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
117 .WillRepeatedly(Return(kTestJid)); | 117 .WillRepeatedly(Return(kTestJid)); |
118 EXPECT_CALL(signal_strategy_, GetNextId()) | 118 EXPECT_CALL(signal_strategy_, GetNextId()) |
119 .WillOnce(Return(kStanzaId)); | 119 .WillOnce(Return(kStanzaId)); |
120 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 120 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
121 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 121 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
122 EXPECT_CALL(signal_strategy_, GetState()) | 122 EXPECT_CALL(signal_strategy_, GetState()) |
123 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 123 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
124 | 124 |
125 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 125 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
126 base::RunLoop().RunUntilIdle(); | 126 base::RunLoop().RunUntilIdle(); |
127 | 127 |
128 scoped_ptr<XmlElement> stanza(sent_iq); | 128 std::unique_ptr<XmlElement> stanza(sent_iq); |
129 ASSERT_TRUE(stanza != nullptr); | 129 ASSERT_TRUE(stanza != nullptr); |
130 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); | 130 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); |
131 | 131 |
132 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 132 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
133 base::RunLoop().RunUntilIdle(); | 133 base::RunLoop().RunUntilIdle(); |
134 } | 134 } |
135 | 135 |
136 // Call Start() followed by Stop(), twice, and make sure two valid heartbeats | 136 // Call Start() followed by Stop(), twice, and make sure two valid heartbeats |
137 // are sent, with the correct sequence IDs. | 137 // are sent, with the correct sequence IDs. |
138 TEST_F(HeartbeatSenderTest, DoSendStanzaTwice) { | 138 TEST_F(HeartbeatSenderTest, DoSendStanzaTwice) { |
139 XmlElement* sent_iq = nullptr; | 139 XmlElement* sent_iq = nullptr; |
140 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 140 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
141 .WillRepeatedly(Return(kTestJid)); | 141 .WillRepeatedly(Return(kTestJid)); |
142 EXPECT_CALL(signal_strategy_, GetNextId()) | 142 EXPECT_CALL(signal_strategy_, GetNextId()) |
143 .WillOnce(Return(kStanzaId)); | 143 .WillOnce(Return(kStanzaId)); |
144 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 144 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
145 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 145 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
146 EXPECT_CALL(signal_strategy_, GetState()) | 146 EXPECT_CALL(signal_strategy_, GetState()) |
147 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 147 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
148 | 148 |
149 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 149 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
150 base::RunLoop().RunUntilIdle(); | 150 base::RunLoop().RunUntilIdle(); |
151 | 151 |
152 scoped_ptr<XmlElement> stanza(sent_iq); | 152 std::unique_ptr<XmlElement> stanza(sent_iq); |
153 ASSERT_TRUE(stanza != nullptr); | 153 ASSERT_TRUE(stanza != nullptr); |
154 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); | 154 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); |
155 | 155 |
156 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 156 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
157 base::RunLoop().RunUntilIdle(); | 157 base::RunLoop().RunUntilIdle(); |
158 | 158 |
159 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 159 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
160 .WillRepeatedly(Return(kTestJid)); | 160 .WillRepeatedly(Return(kTestJid)); |
161 EXPECT_CALL(signal_strategy_, GetNextId()) | 161 EXPECT_CALL(signal_strategy_, GetNextId()) |
162 .WillOnce(Return(kStanzaId + 1)); | 162 .WillOnce(Return(kStanzaId + 1)); |
163 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 163 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
164 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 164 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
165 | 165 |
166 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 166 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
167 base::RunLoop().RunUntilIdle(); | 167 base::RunLoop().RunUntilIdle(); |
168 | 168 |
169 scoped_ptr<XmlElement> stanza2(sent_iq); | 169 std::unique_ptr<XmlElement> stanza2(sent_iq); |
170 ValidateHeartbeatStanza(stanza2.get(), "1", nullptr); | 170 ValidateHeartbeatStanza(stanza2.get(), "1", nullptr); |
171 | 171 |
172 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 172 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
173 base::RunLoop().RunUntilIdle(); | 173 base::RunLoop().RunUntilIdle(); |
174 } | 174 } |
175 | 175 |
176 // Call Start() followed by Stop(), make sure a valid Iq stanza is sent, | 176 // Call Start() followed by Stop(), make sure a valid Iq stanza is sent, |
177 // reply with an expected sequence ID, and make sure two valid heartbeats | 177 // reply with an expected sequence ID, and make sure two valid heartbeats |
178 // are sent, with the correct sequence IDs. | 178 // are sent, with the correct sequence IDs. |
179 TEST_F(HeartbeatSenderTest, DoSendStanzaWithExpectedSequenceId) { | 179 TEST_F(HeartbeatSenderTest, DoSendStanzaWithExpectedSequenceId) { |
180 XmlElement* sent_iq = nullptr; | 180 XmlElement* sent_iq = nullptr; |
181 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 181 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
182 .WillRepeatedly(Return(kTestJid)); | 182 .WillRepeatedly(Return(kTestJid)); |
183 EXPECT_CALL(signal_strategy_, GetNextId()) | 183 EXPECT_CALL(signal_strategy_, GetNextId()) |
184 .WillOnce(Return(kStanzaId)); | 184 .WillOnce(Return(kStanzaId)); |
185 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 185 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
186 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 186 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
187 EXPECT_CALL(signal_strategy_, GetState()) | 187 EXPECT_CALL(signal_strategy_, GetState()) |
188 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 188 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
189 | 189 |
190 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 190 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
191 base::RunLoop().RunUntilIdle(); | 191 base::RunLoop().RunUntilIdle(); |
192 | 192 |
193 scoped_ptr<XmlElement> stanza(sent_iq); | 193 std::unique_ptr<XmlElement> stanza(sent_iq); |
194 ASSERT_TRUE(stanza != nullptr); | 194 ASSERT_TRUE(stanza != nullptr); |
195 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); | 195 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); |
196 | 196 |
197 XmlElement* sent_iq2 = nullptr; | 197 XmlElement* sent_iq2 = nullptr; |
198 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 198 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
199 .WillRepeatedly(Return(kTestJid)); | 199 .WillRepeatedly(Return(kTestJid)); |
200 EXPECT_CALL(signal_strategy_, GetNextId()) | 200 EXPECT_CALL(signal_strategy_, GetNextId()) |
201 .WillOnce(Return(kStanzaId + 1)); | 201 .WillOnce(Return(kStanzaId + 1)); |
202 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 202 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
203 .WillOnce(DoAll(SaveArg<0>(&sent_iq2), Return(true))); | 203 .WillOnce(DoAll(SaveArg<0>(&sent_iq2), Return(true))); |
204 | 204 |
205 scoped_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ)); | 205 std::unique_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ)); |
206 response->AddAttr(QName(std::string(), "type"), "result"); | 206 response->AddAttr(QName(std::string(), "type"), "result"); |
207 XmlElement* result = | 207 XmlElement* result = |
208 new XmlElement(QName(kChromotingXmlNamespace, "heartbeat-result")); | 208 new XmlElement(QName(kChromotingXmlNamespace, "heartbeat-result")); |
209 response->AddElement(result); | 209 response->AddElement(result); |
210 XmlElement* expected_sequence_id = new XmlElement( | 210 XmlElement* expected_sequence_id = new XmlElement( |
211 QName(kChromotingXmlNamespace, "expected-sequence-id")); | 211 QName(kChromotingXmlNamespace, "expected-sequence-id")); |
212 result->AddElement(expected_sequence_id); | 212 result->AddElement(expected_sequence_id); |
213 const int kExpectedSequenceId = 456; | 213 const int kExpectedSequenceId = 456; |
214 expected_sequence_id->AddText(base::IntToString(kExpectedSequenceId)); | 214 expected_sequence_id->AddText(base::IntToString(kExpectedSequenceId)); |
215 heartbeat_sender_->ProcessResponse(false, nullptr, response.get()); | 215 heartbeat_sender_->ProcessResponse(false, nullptr, response.get()); |
216 base::RunLoop().RunUntilIdle(); | 216 base::RunLoop().RunUntilIdle(); |
217 | 217 |
218 scoped_ptr<XmlElement> stanza2(sent_iq2); | 218 std::unique_ptr<XmlElement> stanza2(sent_iq2); |
219 ASSERT_TRUE(stanza2 != nullptr); | 219 ASSERT_TRUE(stanza2 != nullptr); |
220 ValidateHeartbeatStanza(stanza2.get(), | 220 ValidateHeartbeatStanza(stanza2.get(), |
221 base::IntToString(kExpectedSequenceId).c_str(), | 221 base::IntToString(kExpectedSequenceId).c_str(), |
222 nullptr); | 222 nullptr); |
223 | 223 |
224 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 224 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
225 base::RunLoop().RunUntilIdle(); | 225 base::RunLoop().RunUntilIdle(); |
226 } | 226 } |
227 | 227 |
228 void HeartbeatSenderTest::ProcessResponseWithInterval( | 228 void HeartbeatSenderTest::ProcessResponseWithInterval( |
229 bool is_offline_heartbeat_response, | 229 bool is_offline_heartbeat_response, |
230 int interval) { | 230 int interval) { |
231 scoped_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ)); | 231 std::unique_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ)); |
232 response->AddAttr(QName(std::string(), "type"), "result"); | 232 response->AddAttr(QName(std::string(), "type"), "result"); |
233 | 233 |
234 XmlElement* result = new XmlElement( | 234 XmlElement* result = new XmlElement( |
235 QName(kChromotingXmlNamespace, "heartbeat-result")); | 235 QName(kChromotingXmlNamespace, "heartbeat-result")); |
236 response->AddElement(result); | 236 response->AddElement(result); |
237 | 237 |
238 XmlElement* set_interval = new XmlElement( | 238 XmlElement* set_interval = new XmlElement( |
239 QName(kChromotingXmlNamespace, "set-interval")); | 239 QName(kChromotingXmlNamespace, "set-interval")); |
240 result->AddElement(set_interval); | 240 result->AddElement(set_interval); |
241 | 241 |
(...skipping 27 matching lines...) Expand all Loading... |
269 .WillOnce(Return(SignalStrategy::DISCONNECTED)) | 269 .WillOnce(Return(SignalStrategy::DISCONNECTED)) |
270 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 270 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
271 EXPECT_CALL(mock_ack_callback, Run(_)).Times(0); | 271 EXPECT_CALL(mock_ack_callback, Run(_)).Times(0); |
272 | 272 |
273 heartbeat_sender_->SetHostOfflineReason( | 273 heartbeat_sender_->SetHostOfflineReason( |
274 "test_error", kTestTimeout, | 274 "test_error", kTestTimeout, |
275 base::Bind(&MockAckCallback::Run, base::Unretained(&mock_ack_callback))); | 275 base::Bind(&MockAckCallback::Run, base::Unretained(&mock_ack_callback))); |
276 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 276 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
277 base::RunLoop().RunUntilIdle(); | 277 base::RunLoop().RunUntilIdle(); |
278 | 278 |
279 scoped_ptr<XmlElement> stanza(sent_iq); | 279 std::unique_ptr<XmlElement> stanza(sent_iq); |
280 ASSERT_TRUE(stanza != nullptr); | 280 ASSERT_TRUE(stanza != nullptr); |
281 ValidateHeartbeatStanza(stanza.get(), "0", "test_error"); | 281 ValidateHeartbeatStanza(stanza.get(), "0", "test_error"); |
282 | 282 |
283 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 283 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
284 base::RunLoop().RunUntilIdle(); | 284 base::RunLoop().RunUntilIdle(); |
285 } | 285 } |
286 | 286 |
287 // Make sure SetHostOfflineReason triggers a callback when bot responds. | 287 // Make sure SetHostOfflineReason triggers a callback when bot responds. |
288 TEST_F(HeartbeatSenderTest, ProcessHostOfflineResponses) { | 288 TEST_F(HeartbeatSenderTest, ProcessHostOfflineResponses) { |
289 MockAckCallback mock_ack_callback; | 289 MockAckCallback mock_ack_callback; |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
339 EXPECT_CALL(signal_strategy_, GetNextId()) | 339 EXPECT_CALL(signal_strategy_, GetNextId()) |
340 .WillOnce(Return(kStanzaId)); | 340 .WillOnce(Return(kStanzaId)); |
341 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 341 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
342 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 342 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
343 EXPECT_CALL(signal_strategy_, GetState()) | 343 EXPECT_CALL(signal_strategy_, GetState()) |
344 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 344 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
345 | 345 |
346 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 346 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
347 base::RunLoop().RunUntilIdle(); | 347 base::RunLoop().RunUntilIdle(); |
348 | 348 |
349 scoped_ptr<XmlElement> stanza(sent_iq); | 349 std::unique_ptr<XmlElement> stanza(sent_iq); |
350 ASSERT_TRUE(stanza != nullptr); | 350 ASSERT_TRUE(stanza != nullptr); |
351 | 351 |
352 XmlElement* heartbeat_stanza = | 352 XmlElement* heartbeat_stanza = |
353 stanza->FirstNamed(QName(kChromotingXmlNamespace, "heartbeat")); | 353 stanza->FirstNamed(QName(kChromotingXmlNamespace, "heartbeat")); |
354 | 354 |
355 std::string host_os_name = | 355 std::string host_os_name = |
356 heartbeat_stanza->TextNamed( | 356 heartbeat_stanza->TextNamed( |
357 QName(kChromotingXmlNamespace, "host-os-name")); | 357 QName(kChromotingXmlNamespace, "host-os-name")); |
358 EXPECT_TRUE(!host_os_name.empty()); | 358 EXPECT_TRUE(!host_os_name.empty()); |
359 | 359 |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
395 EXPECT_TRUE(heartbeat_stanza->NextNamed(signature_tag) == nullptr); | 395 EXPECT_TRUE(heartbeat_stanza->NextNamed(signature_tag) == nullptr); |
396 | 396 |
397 scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(kTestRsaKeyPair); | 397 scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(kTestRsaKeyPair); |
398 ASSERT_TRUE(key_pair.get()); | 398 ASSERT_TRUE(key_pair.get()); |
399 std::string expected_signature = key_pair->SignMessage( | 399 std::string expected_signature = key_pair->SignMessage( |
400 std::string(kTestJidNormalized) + ' ' + expected_sequence_id); | 400 std::string(kTestJidNormalized) + ' ' + expected_sequence_id); |
401 EXPECT_EQ(expected_signature, signature->BodyText()); | 401 EXPECT_EQ(expected_signature, signature->BodyText()); |
402 } | 402 } |
403 | 403 |
404 } // namespace remoting | 404 } // namespace remoting |
OLD | NEW |