1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "google_apis/gcm/engine/connection_handler_impl.h" 6 7 #include "base/bind.h" 8 #include "base/memory/scoped_ptr.h" 9 #include "base/run_loop.h" 10 #include "base/strings/string_number_conversions.h" 11 #include "base/test/test_timeouts.h" 12 #include "google/protobuf/io/coded_stream.h" 13 #include "google/protobuf/io/zero_copy_stream_impl_lite.h" 14 #include "google_apis/gcm/base/mcs_util.h" 15 #include "google_apis/gcm/base/socket_stream.h" 16 #include "google_apis/gcm/protocol/mcs.pb.h" 17 #include "net/socket/socket_test_util.h" 18 #include "net/socket/stream_socket.h" 19 #include "testing/gtest/include/gtest/gtest.h" 20 21 namespace gcm { 22 namespace { 23 24 typedef scoped_ptr<google::protobuf::MessageLite> ScopedMessage; 25 typedef std::vector<net::MockRead> ReadList; 26 typedef std::vector<net::MockWrite> WriteList; 27 28 const uint64 kAuthId = 54321; 29 const uint64 kAuthToken = 12345; 30 const char kMCSVersion = 41; // The protocol version. 31 const int kMCSPort = 5228; // The server port. 32 const char kDataMsgFrom[] = "data_from"; 33 const char kDataMsgCategory[] = "data_category"; 34 const char kDataMsgFrom2[] = "data_from2"; 35 const char kDataMsgCategory2[] = "data_category2"; 36 const char kDataMsgFromLong[] = 37 "this is a long from that will result in a message > 128 bytes"; 38 const char kDataMsgCategoryLong[] = 39 "this is a long category that will result in a message > 128 bytes"; 40 const char kDataMsgFromLong2[] = 41 "this is a second long from that will result in a message > 128 bytes"; 42 const char kDataMsgCategoryLong2[] = 43 "this is a second long category that will result in a message > 128 bytes"; 44 const uint8 kInvalidTag = 100; // An invalid tag. 45 46 // ---- Helpers for building messages. ---- 47 48 // Encode a protobuf packet with protobuf type |tag| and serialized protobuf 49 // bytes |proto| into the MCS message form (tag + varint size + bytes). 50 std::string EncodePacket(uint8 tag, const std::string& proto) { 51 std::string result; 52 google::protobuf::io::StringOutputStream string_output_stream(&result); 53 { 54 google::protobuf::io::CodedOutputStream coded_output_stream( 55 &string_output_stream); 56 const unsigned char tag_byte[1] = { tag }; 57 coded_output_stream.WriteRaw(tag_byte, 1); 58 coded_output_stream.WriteVarint32(proto.size()); 59 coded_output_stream.WriteRaw(proto.c_str(), proto.size()); 60 // ~CodedOutputStream must run before the move constructor at the 61 // return statement. http://crbug.com/338962 62 } 63 return result; 64 } 65 66 // Encode a handshake request into the MCS message form. 67 std::string EncodeHandshakeRequest() { 68 std::string result; 69 const char version_byte[1] = {kMCSVersion}; 70 result.append(version_byte, 1); 71 ScopedMessage login_request( 72 BuildLoginRequest(kAuthId, kAuthToken, "")); 73 result.append(EncodePacket(kLoginRequestTag, 74 login_request->SerializeAsString())); 75 return result; 76 } 77 78 // Build a serialized login response protobuf. 79 std::string BuildLoginResponse() { 80 std::string result; 81 mcs_proto::LoginResponse login_response; 82 login_response.set_id("id"); 83 result.append(login_response.SerializeAsString()); 84 return result; 85 } 86 87 // Encoode a handshake response into the MCS message form. 88 std::string EncodeHandshakeResponse() { 89 std::string result; 90 const char version_byte[1] = {kMCSVersion}; 91 result.append(version_byte, 1); 92 result.append(EncodePacket(kLoginResponseTag, BuildLoginResponse())); 93 return result; 94 } 95 96 // Build a serialized data message stanza protobuf. 97 std::string BuildDataMessage(const std::string& from, 98 const std::string& category) { 99 std::string result; 100 mcs_proto::DataMessageStanza data_message; 101 data_message.set_from(from); 102 data_message.set_category(category); 103 return data_message.SerializeAsString(); 104 } 105 106 class GCMConnectionHandlerImplTest : public testing::Test { 107 public: 108 GCMConnectionHandlerImplTest(); 109 virtual ~GCMConnectionHandlerImplTest(); 110 111 net::StreamSocket* BuildSocket(const ReadList& read_list, 112 const WriteList& write_list); 113 114 // Pump |message_loop_|, resetting |run_loop_| after completion. 115 void PumpLoop(); 116 117 ConnectionHandlerImpl* connection_handler() { 118 return connection_handler_.get(); 119 } 120 base::MessageLoop* message_loop() { return &message_loop_; }; 121 net::DelayedSocketData* data_provider() { return data_provider_.get(); } 122 int last_error() const { return last_error_; } 123 124 // Initialize the connection handler, setting |dst_proto| as the destination 125 // for any received messages. 126 void Connect(ScopedMessage* dst_proto); 127 128 // Runs the message loop until a message is received. 129 void WaitForMessage(); 130 131 private: 132 void ReadContinuation(ScopedMessage* dst_proto, ScopedMessage new_proto); 133 void WriteContinuation(); 134 void ConnectionContinuation(int error); 135 136 // SocketStreams and their data provider. 137 ReadList mock_reads_; 138 WriteList mock_writes_; 139 scoped_ptr<net::DelayedSocketData> data_provider_; 140 141 // The connection handler being tested. 142 scoped_ptr<ConnectionHandlerImpl> connection_handler_; 143 144 // The last connection error received. 145 int last_error_; 146 147 // net:: components. 148 scoped_ptr<net::StreamSocket> socket_; 149 net::MockClientSocketFactory socket_factory_; 150 net::AddressList address_list_; 151 152 base::MessageLoopForIO message_loop_; 153 scoped_ptr<base::RunLoop> run_loop_; 154 }; 155 156 GCMConnectionHandlerImplTest::GCMConnectionHandlerImplTest() 157 : last_error_(0) { 158 net::IPAddressNumber ip_number; 159 net::ParseIPLiteralToNumber("127.0.0.1", &ip_number); 160 address_list_ = net::AddressList::CreateFromIPAddress(ip_number, kMCSPort); 161 } 162 163 GCMConnectionHandlerImplTest::~GCMConnectionHandlerImplTest() { 164 } 165 166 net::StreamSocket* GCMConnectionHandlerImplTest::BuildSocket( 167 const ReadList& read_list, 168 const WriteList& write_list) { 169 mock_reads_ = read_list; 170 mock_writes_ = write_list; 171 data_provider_.reset( 172 new net::DelayedSocketData(0, 173 &(mock_reads_[0]), mock_reads_.size(), 174 &(mock_writes_[0]), mock_writes_.size())); 175 socket_factory_.AddSocketDataProvider(data_provider_.get()); 176 177 socket_ = socket_factory_.CreateTransportClientSocket( 178 address_list_, NULL, net::NetLog::Source()); 179 socket_->Connect(net::CompletionCallback()); 180 181 run_loop_.reset(new base::RunLoop()); 182 PumpLoop(); 183 184 DCHECK(socket_->IsConnected()); 185 return socket_.get(); 186 } 187 188 void GCMConnectionHandlerImplTest::PumpLoop() { 189 run_loop_->RunUntilIdle(); 190 run_loop_.reset(new base::RunLoop()); 191 } 192 193 void GCMConnectionHandlerImplTest::Connect( 194 ScopedMessage* dst_proto) { 195 connection_handler_.reset(new ConnectionHandlerImpl( 196 TestTimeouts::tiny_timeout(), 197 base::Bind(&GCMConnectionHandlerImplTest::ReadContinuation, 198 base::Unretained(this), 199 dst_proto), 200 base::Bind(&GCMConnectionHandlerImplTest::WriteContinuation, 201 base::Unretained(this)), 202 base::Bind(&GCMConnectionHandlerImplTest::ConnectionContinuation, 203 base::Unretained(this)))); 204 EXPECT_FALSE(connection_handler()->CanSendMessage()); 205 connection_handler_->Init( 206 *BuildLoginRequest(kAuthId, kAuthToken, ""), 207 socket_.get()); 208 } 209 210 void GCMConnectionHandlerImplTest::ReadContinuation( 211 ScopedMessage* dst_proto, 212 ScopedMessage new_proto) { 213 *dst_proto = new_proto.Pass(); 214 run_loop_->Quit(); 215 } 216 217 void GCMConnectionHandlerImplTest::WaitForMessage() { 218 run_loop_->Run(); 219 run_loop_.reset(new base::RunLoop()); 220 } 221 222 void GCMConnectionHandlerImplTest::WriteContinuation() { 223 run_loop_->Quit(); 224 } 225 226 void GCMConnectionHandlerImplTest::ConnectionContinuation(int error) { 227 last_error_ = error; 228 run_loop_->Quit(); 229 } 230 231 // Initialize the connection handler and ensure the handshake completes 232 // successfully. 233 TEST_F(GCMConnectionHandlerImplTest, Init) { 234 std::string handshake_request = EncodeHandshakeRequest(); 235 WriteList write_list(1, net::MockWrite(net::ASYNC, 236 handshake_request.c_str(), 237 handshake_request.size())); 238 std::string handshake_response = EncodeHandshakeResponse(); 239 ReadList read_list(1, net::MockRead(net::ASYNC, 240 handshake_response.c_str(), 241 handshake_response.size())); 242 BuildSocket(read_list, write_list); 243 244 ScopedMessage received_message; 245 Connect(&received_message); 246 EXPECT_FALSE(connection_handler()->CanSendMessage()); 247 WaitForMessage(); // The login send. 248 WaitForMessage(); // The login response. 249 ASSERT_TRUE(received_message.get()); 250 EXPECT_EQ(BuildLoginResponse(), received_message->SerializeAsString()); 251 EXPECT_TRUE(connection_handler()->CanSendMessage()); 252 } 253 254 // Simulate the handshake response returning an older version. Initialization 255 // should fail. 256 TEST_F(GCMConnectionHandlerImplTest, InitFailedVersionCheck) { 257 std::string handshake_request = EncodeHandshakeRequest(); 258 WriteList write_list(1, net::MockWrite(net::ASYNC, 259 handshake_request.c_str(), 260 handshake_request.size())); 261 std::string handshake_response = EncodeHandshakeResponse(); 262 // Overwrite the version byte. 263 handshake_response[0] = 37; 264 ReadList read_list(1, net::MockRead(net::ASYNC, 265 handshake_response.c_str(), 266 handshake_response.size())); 267 BuildSocket(read_list, write_list); 268 269 ScopedMessage received_message; 270 Connect(&received_message); 271 WaitForMessage(); // The login send. 272 WaitForMessage(); // The login response. Should result in a connection error. 273 EXPECT_FALSE(received_message.get()); 274 EXPECT_FALSE(connection_handler()->CanSendMessage()); 275 EXPECT_EQ(net::ERR_FAILED, last_error()); 276 } 277 278 // Attempt to initialize, but receive no server response, resulting in a time 279 // out. 280 TEST_F(GCMConnectionHandlerImplTest, InitTimeout) { 281 std::string handshake_request = EncodeHandshakeRequest(); 282 WriteList write_list(1, net::MockWrite(net::ASYNC, 283 handshake_request.c_str(), 284 handshake_request.size())); 285 ReadList read_list(1, net::MockRead(net::SYNCHRONOUS, 286 net::ERR_IO_PENDING)); 287 BuildSocket(read_list, write_list); 288 289 ScopedMessage received_message; 290 Connect(&received_message); 291 WaitForMessage(); // The login send. 292 WaitForMessage(); // The login response. Should result in a connection error. 293 EXPECT_FALSE(received_message.get()); 294 EXPECT_FALSE(connection_handler()->CanSendMessage()); 295 EXPECT_EQ(net::ERR_TIMED_OUT, last_error()); 296 } 297 298 // Attempt to initialize, but receive an incomplete server response, resulting 299 // in a time out. 300 TEST_F(GCMConnectionHandlerImplTest, InitIncompleteTimeout) { 301 std::string handshake_request = EncodeHandshakeRequest(); 302 WriteList write_list(1, net::MockWrite(net::ASYNC, 303 handshake_request.c_str(), 304 handshake_request.size())); 305 std::string handshake_response = EncodeHandshakeResponse(); 306 ReadList read_list; 307 read_list.push_back(net::MockRead(net::ASYNC, 308 handshake_response.c_str(), 309 handshake_response.size() / 2)); 310 read_list.push_back(net::MockRead(net::SYNCHRONOUS, 311 net::ERR_IO_PENDING)); 312 BuildSocket(read_list, write_list); 313 314 ScopedMessage received_message; 315 Connect(&received_message); 316 WaitForMessage(); // The login send. 317 WaitForMessage(); // The login response. Should result in a connection error. 318 EXPECT_FALSE(received_message.get()); 319 EXPECT_FALSE(connection_handler()->CanSendMessage()); 320 EXPECT_EQ(net::ERR_TIMED_OUT, last_error()); 321 } 322 323 // Reinitialize the connection handler after failing to initialize. 324 TEST_F(GCMConnectionHandlerImplTest, ReInit) { 325 std::string handshake_request = EncodeHandshakeRequest(); 326 WriteList write_list(1, net::MockWrite(net::ASYNC, 327 handshake_request.c_str(), 328 handshake_request.size())); 329 ReadList read_list(1, net::MockRead(net::SYNCHRONOUS, 330 net::ERR_IO_PENDING)); 331 BuildSocket(read_list, write_list); 332 333 ScopedMessage received_message; 334 Connect(&received_message); 335 WaitForMessage(); // The login send. 336 WaitForMessage(); // The login response. Should result in a connection error. 337 EXPECT_FALSE(received_message.get()); 338 EXPECT_FALSE(connection_handler()->CanSendMessage()); 339 EXPECT_EQ(net::ERR_TIMED_OUT, last_error()); 340 341 // Build a new socket and reconnect, successfully this time. 342 std::string handshake_response = EncodeHandshakeResponse(); 343 read_list[0] = net::MockRead(net::ASYNC, 344 handshake_response.c_str(), 345 handshake_response.size()); 346 BuildSocket(read_list, write_list); 347 Connect(&received_message); 348 EXPECT_FALSE(connection_handler()->CanSendMessage()); 349 WaitForMessage(); // The login send. 350 WaitForMessage(); // The login response. 351 ASSERT_TRUE(received_message.get()); 352 EXPECT_EQ(BuildLoginResponse(), received_message->SerializeAsString()); 353 EXPECT_TRUE(connection_handler()->CanSendMessage()); 354 } 355 356 // Verify that messages can be received after initialization. 357 TEST_F(GCMConnectionHandlerImplTest, RecvMsg) { 358 std::string handshake_request = EncodeHandshakeRequest(); 359 WriteList write_list(1, net::MockWrite(net::ASYNC, 360 handshake_request.c_str(), 361 handshake_request.size())); 362 std::string handshake_response = EncodeHandshakeResponse(); 363 364 std::string data_message_proto = BuildDataMessage(kDataMsgFrom, 365 kDataMsgCategory); 366 std::string data_message_pkt = 367 EncodePacket(kDataMessageStanzaTag, data_message_proto); 368 ReadList read_list; 369 read_list.push_back(net::MockRead(net::ASYNC, 370 handshake_response.c_str(), 371 handshake_response.size())); 372 read_list.push_back(net::MockRead(net::ASYNC, 373 data_message_pkt.c_str(), 374 data_message_pkt.size())); 375 BuildSocket(read_list, write_list); 376 377 ScopedMessage received_message; 378 Connect(&received_message); 379 WaitForMessage(); // The login send. 380 WaitForMessage(); // The login response. 381 WaitForMessage(); // The data message. 382 ASSERT_TRUE(received_message.get()); 383 EXPECT_EQ(data_message_proto, received_message->SerializeAsString()); 384 EXPECT_EQ(net::OK, last_error()); 385 } 386 387 // Verify that if two messages arrive at once, they're treated appropriately. 388 TEST_F(GCMConnectionHandlerImplTest, Recv2Msgs) { 389 std::string handshake_request = EncodeHandshakeRequest(); 390 WriteList write_list(1, net::MockWrite(net::ASYNC, 391 handshake_request.c_str(), 392 handshake_request.size())); 393 std::string handshake_response = EncodeHandshakeResponse(); 394 395 std::string data_message_proto = BuildDataMessage(kDataMsgFrom, 396 kDataMsgCategory); 397 std::string data_message_proto2 = BuildDataMessage(kDataMsgFrom2, 398 kDataMsgCategory2); 399 std::string data_message_pkt = 400 EncodePacket(kDataMessageStanzaTag, data_message_proto); 401 data_message_pkt += EncodePacket(kDataMessageStanzaTag, data_message_proto2); 402 ReadList read_list; 403 read_list.push_back(net::MockRead(net::ASYNC, 404 handshake_response.c_str(), 405 handshake_response.size())); 406 read_list.push_back(net::MockRead(net::SYNCHRONOUS, 407 data_message_pkt.c_str(), 408 data_message_pkt.size())); 409 BuildSocket(read_list, write_list); 410 411 ScopedMessage received_message; 412 Connect(&received_message); 413 WaitForMessage(); // The login send. 414 WaitForMessage(); // The login response. 415 WaitForMessage(); // The first data message. 416 ASSERT_TRUE(received_message.get()); 417 EXPECT_EQ(data_message_proto, received_message->SerializeAsString()); 418 received_message.reset(); 419 WaitForMessage(); // The second data message. 420 ASSERT_TRUE(received_message.get()); 421 EXPECT_EQ(data_message_proto2, received_message->SerializeAsString()); 422 EXPECT_EQ(net::OK, last_error()); 423 } 424 425 // Receive a long (>128 bytes) message. 426 TEST_F(GCMConnectionHandlerImplTest, RecvLongMsg) { 427 std::string handshake_request = EncodeHandshakeRequest(); 428 WriteList write_list(1, net::MockWrite(net::ASYNC, 429 handshake_request.c_str(), 430 handshake_request.size())); 431 std::string handshake_response = EncodeHandshakeResponse(); 432 433 std::string data_message_proto = 434 BuildDataMessage(kDataMsgFromLong, kDataMsgCategoryLong); 435 std::string data_message_pkt = 436 EncodePacket(kDataMessageStanzaTag, data_message_proto); 437 DCHECK_GT(data_message_pkt.size(), 128U); 438 ReadList read_list; 439 read_list.push_back(net::MockRead(net::ASYNC, 440 handshake_response.c_str(), 441 handshake_response.size())); 442 read_list.push_back(net::MockRead(net::ASYNC, 443 data_message_pkt.c_str(), 444 data_message_pkt.size())); 445 BuildSocket(read_list, write_list); 446 447 ScopedMessage received_message; 448 Connect(&received_message); 449 WaitForMessage(); // The login send. 450 WaitForMessage(); // The login response. 451 WaitForMessage(); // The data message. 452 ASSERT_TRUE(received_message.get()); 453 EXPECT_EQ(data_message_proto, received_message->SerializeAsString()); 454 EXPECT_EQ(net::OK, last_error()); 455 } 456 457 // Receive a long (>128 bytes) message in two synchronous parts. 458 TEST_F(GCMConnectionHandlerImplTest, RecvLongMsg2Parts) { 459 std::string handshake_request = EncodeHandshakeRequest(); 460 WriteList write_list(1, net::MockWrite(net::ASYNC, 461 handshake_request.c_str(), 462 handshake_request.size())); 463 std::string handshake_response = EncodeHandshakeResponse(); 464 465 std::string data_message_proto = 466 BuildDataMessage(kDataMsgFromLong, kDataMsgCategoryLong); 467 std::string data_message_pkt = 468 EncodePacket(kDataMessageStanzaTag, data_message_proto); 469 DCHECK_GT(data_message_pkt.size(), 128U); 470 ReadList read_list; 471 read_list.push_back(net::MockRead(net::ASYNC, 472 handshake_response.c_str(), 473 handshake_response.size())); 474 475 int bytes_in_first_message = data_message_pkt.size() / 2; 476 read_list.push_back(net::MockRead(net::SYNCHRONOUS, 477 data_message_pkt.c_str(), 478 bytes_in_first_message)); 479 read_list.push_back(net::MockRead(net::SYNCHRONOUS, 480 data_message_pkt.c_str() + 481 bytes_in_first_message, 482 data_message_pkt.size() - 483 bytes_in_first_message)); 484 BuildSocket(read_list, write_list); 485 486 ScopedMessage received_message; 487 Connect(&received_message); 488 WaitForMessage(); // The login send. 489 WaitForMessage(); // The login response. 490 WaitForMessage(); // The data message. 491 ASSERT_TRUE(received_message.get()); 492 EXPECT_EQ(net::OK, last_error()); 493 EXPECT_EQ(data_message_proto, received_message->SerializeAsString()); 494 } 495 496 // Receive two long (>128 bytes) message. 497 TEST_F(GCMConnectionHandlerImplTest, Recv2LongMsgs) { 498 std::string handshake_request = EncodeHandshakeRequest(); 499 WriteList write_list(1, net::MockWrite(net::ASYNC, 500 handshake_request.c_str(), 501 handshake_request.size())); 502 std::string handshake_response = EncodeHandshakeResponse(); 503 504 std::string data_message_proto = 505 BuildDataMessage(kDataMsgFromLong, kDataMsgCategoryLong); 506 std::string data_message_proto2 = 507 BuildDataMessage(kDataMsgFromLong2, kDataMsgCategoryLong2); 508 std::string data_message_pkt = 509 EncodePacket(kDataMessageStanzaTag, data_message_proto); 510 data_message_pkt += EncodePacket(kDataMessageStanzaTag, data_message_proto2); 511 DCHECK_GT(data_message_pkt.size(), 256U); 512 ReadList read_list; 513 read_list.push_back(net::MockRead(net::ASYNC, 514 handshake_response.c_str(), 515 handshake_response.size())); 516 read_list.push_back(net::MockRead(net::SYNCHRONOUS, 517 data_message_pkt.c_str(), 518 data_message_pkt.size())); 519 BuildSocket(read_list, write_list); 520 521 ScopedMessage received_message; 522 Connect(&received_message); 523 WaitForMessage(); // The login send. 524 WaitForMessage(); // The login response. 525 WaitForMessage(); // The first data message. 526 ASSERT_TRUE(received_message.get()); 527 EXPECT_EQ(data_message_proto, received_message->SerializeAsString()); 528 received_message.reset(); 529 WaitForMessage(); // The second data message. 530 ASSERT_TRUE(received_message.get()); 531 EXPECT_EQ(data_message_proto2, received_message->SerializeAsString()); 532 EXPECT_EQ(net::OK, last_error()); 533 } 534 535 // Simulate a message where the end of the data does not arrive in time and the 536 // read times out. 537 TEST_F(GCMConnectionHandlerImplTest, ReadTimeout) { 538 std::string handshake_request = EncodeHandshakeRequest(); 539 WriteList write_list(1, net::MockWrite(net::ASYNC, 540 handshake_request.c_str(), 541 handshake_request.size())); 542 std::string handshake_response = EncodeHandshakeResponse(); 543 544 std::string data_message_proto = BuildDataMessage(kDataMsgFrom, 545 kDataMsgCategory); 546 std::string data_message_pkt = 547 EncodePacket(kDataMessageStanzaTag, data_message_proto); 548 int bytes_in_first_message = data_message_pkt.size() / 2; 549 ReadList read_list; 550 read_list.push_back(net::MockRead(net::ASYNC, 551 handshake_response.c_str(), 552 handshake_response.size())); 553 read_list.push_back(net::MockRead(net::ASYNC, 554 data_message_pkt.c_str(), 555 bytes_in_first_message)); 556 read_list.push_back(net::MockRead(net::SYNCHRONOUS, 557 net::ERR_IO_PENDING)); 558 read_list.push_back(net::MockRead(net::ASYNC, 559 data_message_pkt.c_str() + 560 bytes_in_first_message, 561 data_message_pkt.size() - 562 bytes_in_first_message)); 563 BuildSocket(read_list, write_list); 564 565 ScopedMessage received_message; 566 Connect(&received_message); 567 WaitForMessage(); // The login send. 568 WaitForMessage(); // The login response. 569 received_message.reset(); 570 WaitForMessage(); // Should time out. 571 EXPECT_FALSE(received_message.get()); 572 EXPECT_EQ(net::ERR_TIMED_OUT, last_error()); 573 EXPECT_FALSE(connection_handler()->CanSendMessage()); 574 575 // Finish the socket read. Should have no effect. 576 data_provider()->ForceNextRead(); 577 } 578 579 // Receive a message with zero data bytes. 580 TEST_F(GCMConnectionHandlerImplTest, RecvMsgNoData) { 581 std::string handshake_request = EncodeHandshakeRequest(); 582 WriteList write_list(1, net::MockWrite(net::ASYNC, 583 handshake_request.c_str(), 584 handshake_request.size())); 585 std::string handshake_response = EncodeHandshakeResponse(); 586 587 std::string data_message_pkt = EncodePacket(kHeartbeatPingTag, ""); 588 ASSERT_EQ(data_message_pkt.size(), 2U); 589 ReadList read_list; 590 read_list.push_back(net::MockRead(net::ASYNC, 591 handshake_response.c_str(), 592 handshake_response.size())); 593 read_list.push_back(net::MockRead(net::ASYNC, 594 data_message_pkt.c_str(), 595 data_message_pkt.size())); 596 BuildSocket(read_list, write_list); 597 598 ScopedMessage received_message; 599 Connect(&received_message); 600 WaitForMessage(); // The login send. 601 WaitForMessage(); // The login response. 602 received_message.reset(); 603 WaitForMessage(); // The heartbeat ping. 604 EXPECT_TRUE(received_message.get()); 605 EXPECT_EQ(GetMCSProtoTag(*received_message), kHeartbeatPingTag); 606 EXPECT_EQ(net::OK, last_error()); 607 EXPECT_TRUE(connection_handler()->CanSendMessage()); 608 } 609 610 // Send a message after performing the handshake. 611 TEST_F(GCMConnectionHandlerImplTest, SendMsg) { 612 mcs_proto::DataMessageStanza data_message; 613 data_message.set_from(kDataMsgFrom); 614 data_message.set_category(kDataMsgCategory); 615 std::string handshake_request = EncodeHandshakeRequest(); 616 std::string data_message_pkt = 617 EncodePacket(kDataMessageStanzaTag, data_message.SerializeAsString()); 618 WriteList write_list; 619 write_list.push_back(net::MockWrite(net::ASYNC, 620 handshake_request.c_str(), 621 handshake_request.size())); 622 write_list.push_back(net::MockWrite(net::ASYNC, 623 data_message_pkt.c_str(), 624 data_message_pkt.size())); 625 std::string handshake_response = EncodeHandshakeResponse(); 626 ReadList read_list; 627 read_list.push_back(net::MockRead(net::ASYNC, 628 handshake_response.c_str(), 629 handshake_response.size())); 630 read_list.push_back(net::MockRead(net::SYNCHRONOUS, net::ERR_IO_PENDING)); 631 BuildSocket(read_list, write_list); 632 633 ScopedMessage received_message; 634 Connect(&received_message); 635 WaitForMessage(); // The login send. 636 WaitForMessage(); // The login response. 637 EXPECT_TRUE(connection_handler()->CanSendMessage()); 638 connection_handler()->SendMessage(data_message); 639 EXPECT_FALSE(connection_handler()->CanSendMessage()); 640 WaitForMessage(); // The message send. 641 EXPECT_TRUE(connection_handler()->CanSendMessage()); 642 } 643 644 // Attempt to send a message after the socket is disconnected due to a timeout. 645 TEST_F(GCMConnectionHandlerImplTest, SendMsgSocketDisconnected) { 646 std::string handshake_request = EncodeHandshakeRequest(); 647 WriteList write_list; 648 write_list.push_back(net::MockWrite(net::ASYNC, 649 handshake_request.c_str(), 650 handshake_request.size())); 651 std::string handshake_response = EncodeHandshakeResponse(); 652 ReadList read_list; 653 read_list.push_back(net::MockRead(net::ASYNC, 654 handshake_response.c_str(), 655 handshake_response.size())); 656 read_list.push_back(net::MockRead(net::SYNCHRONOUS, net::ERR_IO_PENDING)); 657 net::StreamSocket* socket = BuildSocket(read_list, write_list); 658 659 ScopedMessage received_message; 660 Connect(&received_message); 661 WaitForMessage(); // The login send. 662 WaitForMessage(); // The login response. 663 EXPECT_TRUE(connection_handler()->CanSendMessage()); 664 socket->Disconnect(); 665 mcs_proto::DataMessageStanza data_message; 666 data_message.set_from(kDataMsgFrom); 667 data_message.set_category(kDataMsgCategory); 668 connection_handler()->SendMessage(data_message); 669 EXPECT_FALSE(connection_handler()->CanSendMessage()); 670 WaitForMessage(); // The message send. Should result in an error 671 EXPECT_FALSE(connection_handler()->CanSendMessage()); 672 EXPECT_EQ(net::ERR_CONNECTION_CLOSED, last_error()); 673 } 674 675 // Receive a message whose size field was corrupted and is larger than the 676 // socket's buffer. Should fail gracefully with a size error. 677 TEST_F(GCMConnectionHandlerImplTest, OutOfBuffer) { 678 std::string handshake_request = EncodeHandshakeRequest(); 679 WriteList write_list(1, net::MockWrite(net::ASYNC, 680 handshake_request.c_str(), 681 handshake_request.size())); 682 std::string handshake_response = EncodeHandshakeResponse(); 683 684 // Fill a string with 9000 character zero. 685 std::string data_message_proto(9000, '0'); 686 std::string data_message_pkt = 687 EncodePacket(kDataMessageStanzaTag, data_message_proto); 688 ReadList read_list; 689 read_list.push_back(net::MockRead(net::ASYNC, 690 handshake_response.c_str(), 691 handshake_response.size())); 692 read_list.push_back(net::MockRead(net::ASYNC, 693 data_message_pkt.c_str(), 694 data_message_pkt.size())); 695 BuildSocket(read_list, write_list); 696 697 ScopedMessage received_message; 698 Connect(&received_message); 699 WaitForMessage(); // The login send. 700 WaitForMessage(); // The login response. 701 received_message.reset(); 702 WaitForMessage(); // The data message. 703 EXPECT_FALSE(received_message.get()); 704 EXPECT_EQ(net::ERR_FILE_TOO_BIG, last_error()); 705 } 706 707 // Receive a message whose size field was corrupted and takes more than two 708 // bytes to encode. Should fail gracefully with a size error. 709 TEST_F(GCMConnectionHandlerImplTest, InvalidSizePacket) { 710 std::string handshake_request = EncodeHandshakeRequest(); 711 WriteList write_list(1, net::MockWrite(net::ASYNC, 712 handshake_request.c_str(), 713 handshake_request.size())); 714 std::string handshake_response = EncodeHandshakeResponse(); 715 716 // Fill a string with 20000 character zero (which uses more than 2 bytes to 717 // encode the size packet). 718 std::string data_message_proto(20000, '0'); 719 std::string data_message_pkt = 720 EncodePacket(kDataMessageStanzaTag, data_message_proto); 721 ReadList read_list; 722 read_list.push_back(net::MockRead(net::ASYNC, 723 handshake_response.c_str(), 724 handshake_response.size())); 725 read_list.push_back(net::MockRead(net::ASYNC, 726 data_message_pkt.c_str(), 727 data_message_pkt.size())); 728 BuildSocket(read_list, write_list); 729 730 ScopedMessage received_message; 731 Connect(&received_message); 732 WaitForMessage(); // The login send. 733 WaitForMessage(); // The login response. 734 received_message.reset(); 735 WaitForMessage(); // The data message. 736 EXPECT_FALSE(received_message.get()); 737 EXPECT_EQ(net::ERR_FILE_TOO_BIG, last_error()); 738 } 739 740 // Make sure a message with an invalid tag is handled gracefully and resets 741 // the connection with an invalid argument error. 742 TEST_F(GCMConnectionHandlerImplTest, InvalidTag) { 743 std::string handshake_request = EncodeHandshakeRequest(); 744 WriteList write_list(1, net::MockWrite(net::ASYNC, 745 handshake_request.c_str(), 746 handshake_request.size())); 747 std::string handshake_response = EncodeHandshakeResponse(); 748 749 std::string invalid_message = "0"; 750 std::string invalid_message_pkt = 751 EncodePacket(kInvalidTag, invalid_message); 752 ReadList read_list; 753 read_list.push_back(net::MockRead(net::ASYNC, 754 handshake_response.c_str(), 755 handshake_response.size())); 756 read_list.push_back(net::MockRead(net::ASYNC, 757 invalid_message_pkt.c_str(), 758 invalid_message_pkt.size())); 759 BuildSocket(read_list, write_list); 760 761 ScopedMessage received_message; 762 Connect(&received_message); 763 WaitForMessage(); // The login send. 764 WaitForMessage(); // The login response. 765 received_message.reset(); 766 WaitForMessage(); // The invalid message. 767 EXPECT_FALSE(received_message.get()); 768 EXPECT_EQ(net::ERR_INVALID_ARGUMENT, last_error()); 769 } 770 771 // Receive a message where the size field spans two socket reads. 772 TEST_F(GCMConnectionHandlerImplTest, RecvMsgSplitSize) { 773 std::string handshake_request = EncodeHandshakeRequest(); 774 WriteList write_list(1, net::MockWrite(net::ASYNC, 775 handshake_request.c_str(), 776 handshake_request.size())); 777 std::string handshake_response = EncodeHandshakeResponse(); 778 779 std::string data_message_proto = 780 BuildDataMessage(kDataMsgFromLong, kDataMsgCategoryLong); 781 std::string data_message_pkt = 782 EncodePacket(kDataMessageStanzaTag, data_message_proto); 783 DCHECK_GT(data_message_pkt.size(), 128U); 784 ReadList read_list; 785 read_list.push_back(net::MockRead(net::ASYNC, 786 handshake_response.c_str(), 787 handshake_response.size())); 788 // The first two bytes are the tag byte and the first byte of the size packet. 789 read_list.push_back(net::MockRead(net::ASYNC, 790 data_message_pkt.c_str(), 791 2)); 792 // Start from the second byte of the size packet. 793 read_list.push_back(net::MockRead(net::ASYNC, 794 data_message_pkt.c_str() + 2, 795 data_message_pkt.size() - 2)); 796 BuildSocket(read_list, write_list); 797 798 ScopedMessage received_message; 799 Connect(&received_message); 800 WaitForMessage(); // The login send. 801 WaitForMessage(); // The login response. 802 WaitForMessage(); // The data message. 803 ASSERT_TRUE(received_message.get()); 804 EXPECT_EQ(data_message_proto, received_message->SerializeAsString()); 805 EXPECT_EQ(net::OK, last_error()); 806 } 807 808 } // namespace 809 } // namespace gcm 810
