1 // Copyright 2014 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 "components/gcm_driver/gcm_driver_desktop.h" 6 7 #include "base/bind.h" 8 #include "base/bind_helpers.h" 9 #include "base/files/scoped_temp_dir.h" 10 #include "base/location.h" 11 #include "base/message_loop/message_loop.h" 12 #include "base/message_loop/message_loop_proxy.h" 13 #include "base/metrics/field_trial.h" 14 #include "base/prefs/pref_registry_simple.h" 15 #include "base/prefs/testing_pref_service.h" 16 #include "base/run_loop.h" 17 #include "base/strings/string_util.h" 18 #include "base/test/test_simple_task_runner.h" 19 #include "base/threading/thread.h" 20 #include "components/gcm_driver/fake_gcm_app_handler.h" 21 #include "components/gcm_driver/fake_gcm_client.h" 22 #include "components/gcm_driver/fake_gcm_client_factory.h" 23 #include "components/gcm_driver/gcm_app_handler.h" 24 #include "components/gcm_driver/gcm_channel_status_request.h" 25 #include "components/gcm_driver/gcm_channel_status_syncer.h" 26 #include "components/gcm_driver/gcm_client_factory.h" 27 #include "components/gcm_driver/gcm_connection_observer.h" 28 #include "net/url_request/test_url_fetcher_factory.h" 29 #include "net/url_request/url_fetcher_delegate.h" 30 #include "net/url_request/url_request_context_getter.h" 31 #include "net/url_request/url_request_test_util.h" 32 #include "sync/protocol/experiment_status.pb.h" 33 #include "sync/protocol/experiments_specifics.pb.h" 34 #include "testing/gtest/include/gtest/gtest.h" 35 36 namespace gcm { 37 38 namespace { 39 40 const char kTestAccountID1[] = "user1 (at) example.com"; 41 const char kTestAccountID2[] = "user2 (at) example.com"; 42 const char kTestAppID1[] = "TestApp1"; 43 const char kTestAppID2[] = "TestApp2"; 44 const char kUserID1[] = "user1"; 45 46 class FakeGCMConnectionObserver : public GCMConnectionObserver { 47 public: 48 FakeGCMConnectionObserver(); 49 virtual ~FakeGCMConnectionObserver(); 50 51 // gcm::GCMConnectionObserver implementation: 52 virtual void OnConnected(const net::IPEndPoint& ip_endpoint) OVERRIDE; 53 virtual void OnDisconnected() OVERRIDE; 54 55 bool connected() const { return connected_; } 56 57 private: 58 bool connected_; 59 }; 60 61 FakeGCMConnectionObserver::FakeGCMConnectionObserver() : connected_(false) { 62 } 63 64 FakeGCMConnectionObserver::~FakeGCMConnectionObserver() { 65 } 66 67 void FakeGCMConnectionObserver::OnConnected( 68 const net::IPEndPoint& ip_endpoint) { 69 connected_ = true; 70 } 71 72 void FakeGCMConnectionObserver::OnDisconnected() { 73 connected_ = false; 74 } 75 76 void PumpCurrentLoop() { 77 base::MessageLoop::ScopedNestableTaskAllower 78 nestable_task_allower(base::MessageLoop::current()); 79 base::RunLoop().RunUntilIdle(); 80 } 81 82 void PumpUILoop() { 83 PumpCurrentLoop(); 84 } 85 86 std::vector<std::string> ToSenderList(const std::string& sender_ids) { 87 std::vector<std::string> senders; 88 Tokenize(sender_ids, ",", &senders); 89 return senders; 90 } 91 92 } // namespace 93 94 class GCMDriverTest : public testing::Test { 95 public: 96 enum WaitToFinish { 97 DO_NOT_WAIT, 98 WAIT 99 }; 100 101 GCMDriverTest(); 102 virtual ~GCMDriverTest(); 103 104 // testing::Test: 105 virtual void SetUp() OVERRIDE; 106 virtual void TearDown() OVERRIDE; 107 108 GCMDriverDesktop* driver() { return driver_.get(); } 109 FakeGCMAppHandler* gcm_app_handler() { return gcm_app_handler_.get(); } 110 FakeGCMConnectionObserver* gcm_connection_observer() { 111 return gcm_connection_observer_.get(); 112 } 113 const std::string& registration_id() const { return registration_id_; } 114 GCMClient::Result registration_result() const { return registration_result_; } 115 const std::string& send_message_id() const { return send_message_id_; } 116 GCMClient::Result send_result() const { return send_result_; } 117 GCMClient::Result unregistration_result() const { 118 return unregistration_result_; 119 } 120 121 void PumpIOLoop(); 122 123 void ClearResults(); 124 125 bool HasAppHandlers() const; 126 FakeGCMClient* GetGCMClient(); 127 128 void CreateDriver(FakeGCMClient::StartMode gcm_client_start_mode); 129 void ShutdownDriver(); 130 void AddAppHandlers(); 131 void RemoveAppHandlers(); 132 133 void SignIn(const std::string& account_id); 134 void SignOut(); 135 136 void Register(const std::string& app_id, 137 const std::vector<std::string>& sender_ids, 138 WaitToFinish wait_to_finish); 139 void Send(const std::string& app_id, 140 const std::string& receiver_id, 141 const GCMClient::OutgoingMessage& message, 142 WaitToFinish wait_to_finish); 143 void Unregister(const std::string& app_id, WaitToFinish wait_to_finish); 144 145 void WaitForAsyncOperation(); 146 147 private: 148 void RegisterCompleted(const std::string& registration_id, 149 GCMClient::Result result); 150 void SendCompleted(const std::string& message_id, GCMClient::Result result); 151 void UnregisterCompleted(GCMClient::Result result); 152 153 base::ScopedTempDir temp_dir_; 154 TestingPrefServiceSimple prefs_; 155 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; 156 base::MessageLoopForUI message_loop_; 157 base::Thread io_thread_; 158 base::FieldTrialList field_trial_list_; 159 scoped_ptr<GCMDriverDesktop> driver_; 160 scoped_ptr<FakeGCMAppHandler> gcm_app_handler_; 161 scoped_ptr<FakeGCMConnectionObserver> gcm_connection_observer_; 162 163 base::Closure async_operation_completed_callback_; 164 165 std::string registration_id_; 166 GCMClient::Result registration_result_; 167 std::string send_message_id_; 168 GCMClient::Result send_result_; 169 GCMClient::Result unregistration_result_; 170 171 DISALLOW_COPY_AND_ASSIGN(GCMDriverTest); 172 }; 173 174 GCMDriverTest::GCMDriverTest() 175 : task_runner_(new base::TestSimpleTaskRunner()), 176 io_thread_("IOThread"), 177 field_trial_list_(NULL), 178 registration_result_(GCMClient::UNKNOWN_ERROR), 179 send_result_(GCMClient::UNKNOWN_ERROR), 180 unregistration_result_(GCMClient::UNKNOWN_ERROR) { 181 } 182 183 GCMDriverTest::~GCMDriverTest() { 184 } 185 186 void GCMDriverTest::SetUp() { 187 GCMChannelStatusSyncer::RegisterPrefs(prefs_.registry()); 188 io_thread_.Start(); 189 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 190 } 191 192 void GCMDriverTest::TearDown() { 193 if (!driver_) 194 return; 195 196 ShutdownDriver(); 197 driver_.reset(); 198 PumpIOLoop(); 199 200 io_thread_.Stop(); 201 } 202 203 void GCMDriverTest::PumpIOLoop() { 204 base::RunLoop run_loop; 205 io_thread_.message_loop_proxy()->PostTaskAndReply( 206 FROM_HERE, 207 base::Bind(&PumpCurrentLoop), 208 run_loop.QuitClosure()); 209 run_loop.Run(); 210 } 211 212 void GCMDriverTest::ClearResults() { 213 registration_id_.clear(); 214 registration_result_ = GCMClient::UNKNOWN_ERROR; 215 216 send_message_id_.clear(); 217 send_result_ = GCMClient::UNKNOWN_ERROR; 218 219 unregistration_result_ = GCMClient::UNKNOWN_ERROR; 220 } 221 222 bool GCMDriverTest::HasAppHandlers() const { 223 return !driver_->app_handlers().empty(); 224 } 225 226 FakeGCMClient* GCMDriverTest::GetGCMClient() { 227 return static_cast<FakeGCMClient*>(driver_->GetGCMClientForTesting()); 228 } 229 230 void GCMDriverTest::CreateDriver( 231 FakeGCMClient::StartMode gcm_client_start_mode) { 232 scoped_refptr<net::URLRequestContextGetter> request_context = 233 new net::TestURLRequestContextGetter(io_thread_.message_loop_proxy()); 234 // TODO(johnme): Need equivalent test coverage of GCMDriverAndroid. 235 driver_.reset(new GCMDriverDesktop( 236 scoped_ptr<GCMClientFactory>( 237 new FakeGCMClientFactory(gcm_client_start_mode, 238 base::MessageLoopProxy::current(), 239 io_thread_.message_loop_proxy())).Pass(), 240 GCMClient::ChromeBuildInfo(), 241 "http://channel.status.request.url", 242 "user-agent-string", 243 &prefs_, 244 temp_dir_.path(), 245 request_context, 246 base::MessageLoopProxy::current(), 247 io_thread_.message_loop_proxy(), 248 task_runner_)); 249 250 gcm_app_handler_.reset(new FakeGCMAppHandler); 251 gcm_connection_observer_.reset(new FakeGCMConnectionObserver); 252 253 driver_->AddConnectionObserver(gcm_connection_observer_.get()); 254 } 255 256 void GCMDriverTest::ShutdownDriver() { 257 if (gcm_connection_observer()) 258 driver()->RemoveConnectionObserver(gcm_connection_observer()); 259 driver()->Shutdown(); 260 } 261 262 void GCMDriverTest::AddAppHandlers() { 263 driver_->AddAppHandler(kTestAppID1, gcm_app_handler_.get()); 264 driver_->AddAppHandler(kTestAppID2, gcm_app_handler_.get()); 265 } 266 267 void GCMDriverTest::RemoveAppHandlers() { 268 driver_->RemoveAppHandler(kTestAppID1); 269 driver_->RemoveAppHandler(kTestAppID2); 270 } 271 272 void GCMDriverTest::SignIn(const std::string& account_id) { 273 driver_->OnSignedIn(); 274 PumpIOLoop(); 275 PumpUILoop(); 276 } 277 278 void GCMDriverTest::SignOut() { 279 driver_->OnSignedOut(); 280 PumpIOLoop(); 281 PumpUILoop(); 282 } 283 284 void GCMDriverTest::Register(const std::string& app_id, 285 const std::vector<std::string>& sender_ids, 286 WaitToFinish wait_to_finish) { 287 base::RunLoop run_loop; 288 async_operation_completed_callback_ = run_loop.QuitClosure(); 289 driver_->Register(app_id, 290 sender_ids, 291 base::Bind(&GCMDriverTest::RegisterCompleted, 292 base::Unretained(this))); 293 if (wait_to_finish == WAIT) 294 run_loop.Run(); 295 } 296 297 void GCMDriverTest::Send(const std::string& app_id, 298 const std::string& receiver_id, 299 const GCMClient::OutgoingMessage& message, 300 WaitToFinish wait_to_finish) { 301 base::RunLoop run_loop; 302 async_operation_completed_callback_ = run_loop.QuitClosure(); 303 driver_->Send(app_id, 304 receiver_id, 305 message, 306 base::Bind(&GCMDriverTest::SendCompleted, 307 base::Unretained(this))); 308 if (wait_to_finish == WAIT) 309 run_loop.Run(); 310 } 311 312 void GCMDriverTest::Unregister(const std::string& app_id, 313 WaitToFinish wait_to_finish) { 314 base::RunLoop run_loop; 315 async_operation_completed_callback_ = run_loop.QuitClosure(); 316 driver_->Unregister(app_id, 317 base::Bind(&GCMDriverTest::UnregisterCompleted, 318 base::Unretained(this))); 319 if (wait_to_finish == WAIT) 320 run_loop.Run(); 321 } 322 323 void GCMDriverTest::WaitForAsyncOperation() { 324 base::RunLoop run_loop; 325 async_operation_completed_callback_ = run_loop.QuitClosure(); 326 run_loop.Run(); 327 } 328 329 void GCMDriverTest::RegisterCompleted(const std::string& registration_id, 330 GCMClient::Result result) { 331 registration_id_ = registration_id; 332 registration_result_ = result; 333 if (!async_operation_completed_callback_.is_null()) 334 async_operation_completed_callback_.Run(); 335 } 336 337 void GCMDriverTest::SendCompleted(const std::string& message_id, 338 GCMClient::Result result) { 339 send_message_id_ = message_id; 340 send_result_ = result; 341 if (!async_operation_completed_callback_.is_null()) 342 async_operation_completed_callback_.Run(); 343 } 344 345 void GCMDriverTest::UnregisterCompleted(GCMClient::Result result) { 346 unregistration_result_ = result; 347 if (!async_operation_completed_callback_.is_null()) 348 async_operation_completed_callback_.Run(); 349 } 350 351 TEST_F(GCMDriverTest, Create) { 352 // Create GCMDriver first. GCM is not started. 353 CreateDriver(FakeGCMClient::NO_DELAY_START); 354 EXPECT_FALSE(driver()->IsStarted()); 355 356 // Sign in. GCM is still not started. 357 SignIn(kTestAccountID1); 358 EXPECT_FALSE(driver()->IsStarted()); 359 EXPECT_FALSE(driver()->IsConnected()); 360 EXPECT_FALSE(gcm_connection_observer()->connected()); 361 362 // GCM will be started only after both sign-in and app handler being added. 363 AddAppHandlers(); 364 EXPECT_TRUE(driver()->IsStarted()); 365 PumpIOLoop(); 366 EXPECT_TRUE(driver()->IsConnected()); 367 EXPECT_TRUE(gcm_connection_observer()->connected()); 368 } 369 370 TEST_F(GCMDriverTest, CreateByFieldTrial) { 371 ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("GCM", "Enabled")); 372 373 // Create GCMDriver first. GCM is not started. 374 CreateDriver(FakeGCMClient::NO_DELAY_START); 375 EXPECT_FALSE(driver()->IsStarted()); 376 EXPECT_FALSE(driver()->IsConnected()); 377 EXPECT_FALSE(gcm_connection_observer()->connected()); 378 379 // GCM will be started after app handler is added. 380 AddAppHandlers(); 381 EXPECT_TRUE(driver()->IsStarted()); 382 PumpIOLoop(); 383 EXPECT_TRUE(driver()->IsConnected()); 384 EXPECT_TRUE(gcm_connection_observer()->connected()); 385 386 // Sign-in will not affect GCM state. 387 SignIn(kTestAccountID1); 388 PumpIOLoop(); 389 EXPECT_TRUE(driver()->IsStarted()); 390 EXPECT_TRUE(driver()->IsConnected()); 391 392 // Sign-out will not affect GCM state. 393 SignOut(); 394 PumpIOLoop(); 395 EXPECT_TRUE(driver()->IsStarted()); 396 EXPECT_TRUE(driver()->IsConnected()); 397 } 398 399 TEST_F(GCMDriverTest, Shutdown) { 400 CreateDriver(FakeGCMClient::NO_DELAY_START); 401 EXPECT_FALSE(HasAppHandlers()); 402 403 AddAppHandlers(); 404 EXPECT_TRUE(HasAppHandlers()); 405 406 ShutdownDriver(); 407 EXPECT_FALSE(HasAppHandlers()); 408 EXPECT_FALSE(driver()->IsConnected()); 409 EXPECT_FALSE(gcm_connection_observer()->connected()); 410 } 411 412 TEST_F(GCMDriverTest, SignInAndSignOutOnGCMEnabled) { 413 // By default, GCM is enabled. 414 CreateDriver(FakeGCMClient::NO_DELAY_START); 415 AddAppHandlers(); 416 417 // GCMClient should be started after sign-in. 418 SignIn(kTestAccountID1); 419 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 420 421 // GCMClient should be stopped out after sign-out. 422 // Note: Before we enable the feature that drops the sign-in enforcement and 423 // make GCM work for all users, GCM is only applicable to signed-in users. 424 // Once the users sign out, the GCM will be shut down while the GCM store 425 // remains intact. 426 SignOut(); 427 EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status()); 428 } 429 430 TEST_F(GCMDriverTest, SignInAndSignOutOnGCMDisabled) { 431 // By default, GCM is enabled. 432 CreateDriver(FakeGCMClient::NO_DELAY_START); 433 AddAppHandlers(); 434 435 // Disable GCM. 436 driver()->Disable(); 437 438 // GCMClient should not be started after sign-in. 439 SignIn(kTestAccountID1); 440 EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status()); 441 442 // GCMClient should remain not started after sign-out. 443 SignOut(); 444 EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status()); 445 } 446 447 TEST_F(GCMDriverTest, SignOutAndThenSignIn) { 448 CreateDriver(FakeGCMClient::NO_DELAY_START); 449 AddAppHandlers(); 450 451 // GCMClient should be started after sign-in. 452 SignIn(kTestAccountID1); 453 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 454 455 // GCMClient should be stopped after sign-out. 456 SignOut(); 457 EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status()); 458 459 // Sign-in with a different account. 460 SignIn(kTestAccountID2); 461 462 // GCMClient should be started again. 463 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 464 } 465 466 TEST_F(GCMDriverTest, DisableAndReenableGCM) { 467 CreateDriver(FakeGCMClient::NO_DELAY_START); 468 AddAppHandlers(); 469 SignIn(kTestAccountID1); 470 471 // GCMClient should be started. 472 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 473 474 // Disables the GCM. 475 driver()->Disable(); 476 PumpIOLoop(); 477 PumpUILoop(); 478 479 // GCMClient should be stopped. 480 EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status()); 481 482 // Enables the GCM. 483 driver()->Enable(); 484 PumpIOLoop(); 485 PumpUILoop(); 486 487 // GCMClient should be started. 488 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 489 490 // Disables the GCM. 491 driver()->Disable(); 492 PumpIOLoop(); 493 PumpUILoop(); 494 495 // GCMClient should be stopped. 496 EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status()); 497 498 // Sign out. 499 SignOut(); 500 501 // GCMClient should be stopped. 502 EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status()); 503 } 504 505 TEST_F(GCMDriverTest, StartOrStopGCMOnDemand) { 506 CreateDriver(FakeGCMClient::NO_DELAY_START); 507 SignIn(kTestAccountID1); 508 509 // GCMClient is not started. 510 EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status()); 511 512 // GCMClient is started after an app handler has been added. 513 driver()->AddAppHandler(kTestAppID1, gcm_app_handler()); 514 PumpIOLoop(); 515 PumpUILoop(); 516 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 517 518 // Add another app handler. 519 driver()->AddAppHandler(kTestAppID2, gcm_app_handler()); 520 PumpIOLoop(); 521 PumpUILoop(); 522 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 523 524 // GCMClient remains active after one app handler is gone. 525 driver()->RemoveAppHandler(kTestAppID1); 526 PumpIOLoop(); 527 PumpUILoop(); 528 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 529 530 // GCMClient should be stopped after the last app handler is gone. 531 driver()->RemoveAppHandler(kTestAppID2); 532 PumpIOLoop(); 533 PumpUILoop(); 534 EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status()); 535 536 // GCMClient is restarted after an app handler has been added. 537 driver()->AddAppHandler(kTestAppID2, gcm_app_handler()); 538 PumpIOLoop(); 539 PumpUILoop(); 540 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 541 } 542 543 TEST_F(GCMDriverTest, RegisterFailed) { 544 std::vector<std::string> sender_ids; 545 sender_ids.push_back("sender1"); 546 547 CreateDriver(FakeGCMClient::NO_DELAY_START); 548 549 // Registration fails when GCM is disabled. 550 driver()->Disable(); 551 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 552 EXPECT_TRUE(registration_id().empty()); 553 EXPECT_EQ(GCMClient::GCM_DISABLED, registration_result()); 554 555 ClearResults(); 556 557 // Registration fails when the sign-in does not occur. 558 driver()->Enable(); 559 AddAppHandlers(); 560 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 561 EXPECT_TRUE(registration_id().empty()); 562 EXPECT_EQ(GCMClient::NOT_SIGNED_IN, registration_result()); 563 564 ClearResults(); 565 566 // Registration fails when the no app handler is added. 567 RemoveAppHandlers(); 568 SignIn(kTestAccountID1); 569 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 570 EXPECT_TRUE(registration_id().empty()); 571 EXPECT_EQ(GCMClient::UNKNOWN_ERROR, registration_result()); 572 } 573 574 TEST_F(GCMDriverTest, UnregisterFailed) { 575 CreateDriver(FakeGCMClient::NO_DELAY_START); 576 577 // Unregistration fails when GCM is disabled. 578 driver()->Disable(); 579 Unregister(kTestAppID1, GCMDriverTest::WAIT); 580 EXPECT_EQ(GCMClient::GCM_DISABLED, unregistration_result()); 581 582 ClearResults(); 583 584 // Unregistration fails when the sign-in does not occur. 585 driver()->Enable(); 586 AddAppHandlers(); 587 Unregister(kTestAppID1, GCMDriverTest::WAIT); 588 EXPECT_EQ(GCMClient::NOT_SIGNED_IN, unregistration_result()); 589 590 ClearResults(); 591 592 // Unregistration fails when the no app handler is added. 593 RemoveAppHandlers(); 594 SignIn(kTestAccountID1); 595 Unregister(kTestAppID1, GCMDriverTest::WAIT); 596 EXPECT_EQ(GCMClient::UNKNOWN_ERROR, unregistration_result()); 597 } 598 599 TEST_F(GCMDriverTest, SendFailed) { 600 GCMClient::OutgoingMessage message; 601 message.id = "1"; 602 message.data["key1"] = "value1"; 603 604 CreateDriver(FakeGCMClient::NO_DELAY_START); 605 606 // Sending fails when GCM is disabled. 607 driver()->Disable(); 608 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 609 EXPECT_TRUE(send_message_id().empty()); 610 EXPECT_EQ(GCMClient::GCM_DISABLED, send_result()); 611 612 ClearResults(); 613 614 // Sending fails when the sign-in does not occur. 615 driver()->Enable(); 616 AddAppHandlers(); 617 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 618 EXPECT_TRUE(send_message_id().empty()); 619 EXPECT_EQ(GCMClient::NOT_SIGNED_IN, send_result()); 620 621 ClearResults(); 622 623 // Sending fails when the no app handler is added. 624 RemoveAppHandlers(); 625 SignIn(kTestAccountID1); 626 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 627 EXPECT_TRUE(send_message_id().empty()); 628 EXPECT_EQ(GCMClient::UNKNOWN_ERROR, send_result()); 629 } 630 631 TEST_F(GCMDriverTest, GCMClientNotReadyBeforeRegistration) { 632 // Make GCMClient not ready initially. 633 CreateDriver(FakeGCMClient::DELAY_START); 634 SignIn(kTestAccountID1); 635 AddAppHandlers(); 636 637 // The registration is on hold until GCMClient is ready. 638 std::vector<std::string> sender_ids; 639 sender_ids.push_back("sender1"); 640 Register(kTestAppID1, 641 sender_ids, 642 GCMDriverTest::DO_NOT_WAIT); 643 PumpIOLoop(); 644 PumpUILoop(); 645 EXPECT_TRUE(registration_id().empty()); 646 EXPECT_EQ(GCMClient::UNKNOWN_ERROR, registration_result()); 647 648 // Register operation will be invoked after GCMClient becomes ready. 649 GetGCMClient()->PerformDelayedLoading(); 650 WaitForAsyncOperation(); 651 EXPECT_FALSE(registration_id().empty()); 652 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 653 } 654 655 TEST_F(GCMDriverTest, GCMClientNotReadyBeforeSending) { 656 // Make GCMClient not ready initially. 657 CreateDriver(FakeGCMClient::DELAY_START); 658 SignIn(kTestAccountID1); 659 AddAppHandlers(); 660 661 // The sending is on hold until GCMClient is ready. 662 GCMClient::OutgoingMessage message; 663 message.id = "1"; 664 message.data["key1"] = "value1"; 665 message.data["key2"] = "value2"; 666 Send(kTestAppID1, kUserID1, message, GCMDriverTest::DO_NOT_WAIT); 667 PumpIOLoop(); 668 PumpUILoop(); 669 670 EXPECT_TRUE(send_message_id().empty()); 671 EXPECT_EQ(GCMClient::UNKNOWN_ERROR, send_result()); 672 673 // Send operation will be invoked after GCMClient becomes ready. 674 GetGCMClient()->PerformDelayedLoading(); 675 WaitForAsyncOperation(); 676 EXPECT_EQ(message.id, send_message_id()); 677 EXPECT_EQ(GCMClient::SUCCESS, send_result()); 678 } 679 680 // Tests a single instance of GCMDriver. 681 class GCMDriverFunctionalTest : public GCMDriverTest { 682 public: 683 GCMDriverFunctionalTest(); 684 virtual ~GCMDriverFunctionalTest(); 685 686 // GCMDriverTest: 687 virtual void SetUp() OVERRIDE; 688 689 private: 690 DISALLOW_COPY_AND_ASSIGN(GCMDriverFunctionalTest); 691 }; 692 693 GCMDriverFunctionalTest::GCMDriverFunctionalTest() { 694 } 695 696 GCMDriverFunctionalTest::~GCMDriverFunctionalTest() { 697 } 698 699 void GCMDriverFunctionalTest::SetUp() { 700 GCMDriverTest::SetUp(); 701 702 CreateDriver(FakeGCMClient::NO_DELAY_START); 703 AddAppHandlers(); 704 SignIn(kTestAccountID1); 705 } 706 707 TEST_F(GCMDriverFunctionalTest, Register) { 708 std::vector<std::string> sender_ids; 709 sender_ids.push_back("sender1"); 710 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 711 const std::string expected_registration_id = 712 GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids); 713 714 EXPECT_EQ(expected_registration_id, registration_id()); 715 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 716 } 717 718 TEST_F(GCMDriverFunctionalTest, RegisterError) { 719 std::vector<std::string> sender_ids; 720 sender_ids.push_back("sender1@error"); 721 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 722 723 EXPECT_TRUE(registration_id().empty()); 724 EXPECT_NE(GCMClient::SUCCESS, registration_result()); 725 } 726 727 TEST_F(GCMDriverFunctionalTest, RegisterAgainWithSameSenderIDs) { 728 std::vector<std::string> sender_ids; 729 sender_ids.push_back("sender1"); 730 sender_ids.push_back("sender2"); 731 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 732 const std::string expected_registration_id = 733 GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids); 734 735 EXPECT_EQ(expected_registration_id, registration_id()); 736 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 737 738 // Clears the results the would be set by the Register callback in preparation 739 // to call register 2nd time. 740 ClearResults(); 741 742 // Calling register 2nd time with the same set of sender IDs but different 743 // ordering will get back the same registration ID. 744 std::vector<std::string> another_sender_ids; 745 another_sender_ids.push_back("sender2"); 746 another_sender_ids.push_back("sender1"); 747 Register(kTestAppID1, another_sender_ids, GCMDriverTest::WAIT); 748 749 EXPECT_EQ(expected_registration_id, registration_id()); 750 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 751 } 752 753 TEST_F(GCMDriverFunctionalTest, RegisterAgainWithDifferentSenderIDs) { 754 std::vector<std::string> sender_ids; 755 sender_ids.push_back("sender1"); 756 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 757 const std::string expected_registration_id = 758 GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids); 759 760 EXPECT_EQ(expected_registration_id, registration_id()); 761 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 762 763 // Make sender IDs different. 764 sender_ids.push_back("sender2"); 765 const std::string expected_registration_id2 = 766 GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids); 767 768 // Calling register 2nd time with the different sender IDs will get back a new 769 // registration ID. 770 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 771 EXPECT_EQ(expected_registration_id2, registration_id()); 772 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 773 } 774 775 TEST_F(GCMDriverFunctionalTest, RegisterAfterSignOut) { 776 SignOut(); 777 778 std::vector<std::string> sender_ids; 779 sender_ids.push_back("sender1"); 780 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 781 782 EXPECT_TRUE(registration_id().empty()); 783 EXPECT_EQ(GCMClient::NOT_SIGNED_IN, registration_result()); 784 } 785 786 TEST_F(GCMDriverFunctionalTest, RegisterAfterSignOutAndSignInAgain) { 787 std::vector<std::string> sender_ids; 788 sender_ids.push_back("sender1"); 789 const std::string expected_registration_id = 790 GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids); 791 792 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 793 EXPECT_EQ(expected_registration_id, registration_id()); 794 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 795 796 // After signing out, the GCM is stopped and calling register should fail. 797 SignOut(); 798 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 799 EXPECT_TRUE(registration_id().empty()); 800 EXPECT_EQ(GCMClient::NOT_SIGNED_IN, registration_result()); 801 802 // After signing in again, same registration ID should be returned because 803 // the GCM data is not affected. 804 SignIn(kTestAccountID1); 805 806 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 807 EXPECT_EQ(expected_registration_id, registration_id()); 808 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 809 } 810 811 TEST_F(GCMDriverFunctionalTest, UnregisterExplicitly) { 812 std::vector<std::string> sender_ids; 813 sender_ids.push_back("sender1"); 814 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 815 816 EXPECT_FALSE(registration_id().empty()); 817 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 818 819 Unregister(kTestAppID1, GCMDriverTest::WAIT); 820 821 EXPECT_EQ(GCMClient::SUCCESS, unregistration_result()); 822 } 823 824 TEST_F(GCMDriverFunctionalTest, UnregisterWhenAsyncOperationPending) { 825 std::vector<std::string> sender_ids; 826 sender_ids.push_back("sender1"); 827 // First start registration without waiting for it to complete. 828 Register(kTestAppID1, 829 sender_ids, 830 GCMDriverTest::DO_NOT_WAIT); 831 832 // Test that unregistration fails with async operation pending when there is a 833 // registration already in progress. 834 Unregister(kTestAppID1, GCMDriverTest::WAIT); 835 EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING, 836 unregistration_result()); 837 838 // Complete the unregistration. 839 WaitForAsyncOperation(); 840 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 841 842 // Start unregistration without waiting for it to complete. This time no async 843 // operation is pending. 844 Unregister(kTestAppID1, GCMDriverTest::DO_NOT_WAIT); 845 846 // Test that unregistration fails with async operation pending when there is 847 // an unregistration already in progress. 848 Unregister(kTestAppID1, GCMDriverTest::WAIT); 849 EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING, 850 unregistration_result()); 851 ClearResults(); 852 853 // Complete unregistration. 854 WaitForAsyncOperation(); 855 EXPECT_EQ(GCMClient::SUCCESS, unregistration_result()); 856 } 857 858 TEST_F(GCMDriverFunctionalTest, RegisterWhenAsyncOperationPending) { 859 std::vector<std::string> sender_ids; 860 sender_ids.push_back("sender1"); 861 // First start registration without waiting for it to complete. 862 Register(kTestAppID1, 863 sender_ids, 864 GCMDriverTest::DO_NOT_WAIT); 865 866 // Test that registration fails with async operation pending when there is a 867 // registration already in progress. 868 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 869 EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING, 870 registration_result()); 871 ClearResults(); 872 873 // Complete the registration. 874 WaitForAsyncOperation(); 875 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 876 877 // Start unregistration without waiting for it to complete. This time no async 878 // operation is pending. 879 Unregister(kTestAppID1, GCMDriverTest::DO_NOT_WAIT); 880 881 // Test that registration fails with async operation pending when there is an 882 // unregistration already in progress. 883 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 884 EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING, 885 registration_result()); 886 887 // Complete the first unregistration expecting success. 888 WaitForAsyncOperation(); 889 EXPECT_EQ(GCMClient::SUCCESS, unregistration_result()); 890 891 // Test that it is ok to register again after unregistration. 892 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 893 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 894 } 895 896 TEST_F(GCMDriverFunctionalTest, Send) { 897 GCMClient::OutgoingMessage message; 898 message.id = "1@ack"; 899 message.data["key1"] = "value1"; 900 message.data["key2"] = "value2"; 901 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 902 903 EXPECT_EQ(message.id, send_message_id()); 904 EXPECT_EQ(GCMClient::SUCCESS, send_result()); 905 906 gcm_app_handler()->WaitForNotification(); 907 EXPECT_EQ(message.id, gcm_app_handler()->acked_message_id()); 908 EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id()); 909 } 910 911 TEST_F(GCMDriverFunctionalTest, SendAfterSignOut) { 912 SignOut(); 913 914 GCMClient::OutgoingMessage message; 915 message.id = "1"; 916 message.data["key1"] = "value1"; 917 message.data["key2"] = "value2"; 918 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 919 920 EXPECT_TRUE(send_message_id().empty()); 921 EXPECT_EQ(GCMClient::NOT_SIGNED_IN, send_result()); 922 } 923 924 TEST_F(GCMDriverFunctionalTest, SendError) { 925 GCMClient::OutgoingMessage message; 926 // Embedding error in id will tell the mock to simulate the send error. 927 message.id = "1@error"; 928 message.data["key1"] = "value1"; 929 message.data["key2"] = "value2"; 930 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 931 932 EXPECT_EQ(message.id, send_message_id()); 933 EXPECT_EQ(GCMClient::SUCCESS, send_result()); 934 935 // Wait for the send error. 936 gcm_app_handler()->WaitForNotification(); 937 EXPECT_EQ(FakeGCMAppHandler::SEND_ERROR_EVENT, 938 gcm_app_handler()->received_event()); 939 EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id()); 940 EXPECT_EQ(message.id, 941 gcm_app_handler()->send_error_details().message_id); 942 EXPECT_NE(GCMClient::SUCCESS, 943 gcm_app_handler()->send_error_details().result); 944 EXPECT_EQ(message.data, 945 gcm_app_handler()->send_error_details().additional_data); 946 } 947 948 TEST_F(GCMDriverFunctionalTest, MessageReceived) { 949 Register(kTestAppID1, ToSenderList("sender"), GCMDriverTest::WAIT); 950 GCMClient::IncomingMessage message; 951 message.data["key1"] = "value1"; 952 message.data["key2"] = "value2"; 953 message.sender_id = "sender"; 954 GetGCMClient()->ReceiveMessage(kTestAppID1, message); 955 gcm_app_handler()->WaitForNotification(); 956 EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT, 957 gcm_app_handler()->received_event()); 958 EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id()); 959 EXPECT_EQ(message.data, gcm_app_handler()->message().data); 960 EXPECT_TRUE(gcm_app_handler()->message().collapse_key.empty()); 961 EXPECT_EQ(message.sender_id, gcm_app_handler()->message().sender_id); 962 } 963 964 TEST_F(GCMDriverFunctionalTest, MessageWithCollapseKeyReceived) { 965 Register(kTestAppID1, ToSenderList("sender"), GCMDriverTest::WAIT); 966 GCMClient::IncomingMessage message; 967 message.data["key1"] = "value1"; 968 message.collapse_key = "collapse_key_value"; 969 message.sender_id = "sender"; 970 GetGCMClient()->ReceiveMessage(kTestAppID1, message); 971 gcm_app_handler()->WaitForNotification(); 972 EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT, 973 gcm_app_handler()->received_event()); 974 EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id()); 975 EXPECT_EQ(message.data, gcm_app_handler()->message().data); 976 EXPECT_EQ(message.collapse_key, 977 gcm_app_handler()->message().collapse_key); 978 } 979 980 TEST_F(GCMDriverFunctionalTest, MessagesDeleted) { 981 GetGCMClient()->DeleteMessages(kTestAppID1); 982 gcm_app_handler()->WaitForNotification(); 983 EXPECT_EQ(FakeGCMAppHandler::MESSAGES_DELETED_EVENT, 984 gcm_app_handler()->received_event()); 985 EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id()); 986 } 987 988 // Tests a single instance of GCMDriver. 989 class GCMChannelStatusSyncerTest : public GCMDriverTest { 990 public: 991 GCMChannelStatusSyncerTest(); 992 virtual ~GCMChannelStatusSyncerTest(); 993 994 // testing::Test: 995 virtual void SetUp() OVERRIDE; 996 997 void CompleteGCMChannelStatusRequest(bool enabled, int poll_interval_seconds); 998 bool CompareDelaySeconds(bool expected_delay_seconds, 999 bool actual_delay_seconds); 1000 1001 GCMChannelStatusSyncer* syncer() { 1002 return driver()->gcm_channel_status_syncer_for_testing(); 1003 } 1004 1005 private: 1006 net::TestURLFetcherFactory url_fetcher_factory_; 1007 1008 DISALLOW_COPY_AND_ASSIGN(GCMChannelStatusSyncerTest); 1009 }; 1010 1011 GCMChannelStatusSyncerTest::GCMChannelStatusSyncerTest() { 1012 } 1013 1014 GCMChannelStatusSyncerTest::~GCMChannelStatusSyncerTest() { 1015 } 1016 1017 void GCMChannelStatusSyncerTest::SetUp() { 1018 GCMDriverTest::SetUp(); 1019 1020 url_fetcher_factory_.set_remove_fetcher_on_delete(true); 1021 1022 // Turn on all-user support. 1023 ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("GCM", "Enabled")); 1024 } 1025 1026 void GCMChannelStatusSyncerTest::CompleteGCMChannelStatusRequest( 1027 bool enabled, int poll_interval_seconds) { 1028 sync_pb::ExperimentStatusResponse response_proto; 1029 sync_pb::ExperimentsSpecifics* experiment_specifics = 1030 response_proto.add_experiment(); 1031 experiment_specifics->mutable_gcm_channel()->set_enabled(enabled); 1032 1033 if (poll_interval_seconds) 1034 response_proto.set_poll_interval_seconds(poll_interval_seconds); 1035 1036 std::string response_string; 1037 response_proto.SerializeToString(&response_string); 1038 1039 net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0); 1040 ASSERT_TRUE(fetcher); 1041 fetcher->set_response_code(net::HTTP_OK); 1042 fetcher->SetResponseString(response_string); 1043 fetcher->delegate()->OnURLFetchComplete(fetcher); 1044 } 1045 1046 bool GCMChannelStatusSyncerTest::CompareDelaySeconds( 1047 bool expected_delay_seconds, bool actual_delay_seconds) { 1048 // Most of time, the actual delay should not be smaller than the expected 1049 // delay. 1050 if (actual_delay_seconds >= expected_delay_seconds) 1051 return true; 1052 // It is also OK that the actual delay is a bit smaller than the expected 1053 // delay in case that the test runs slowly. 1054 return expected_delay_seconds - actual_delay_seconds < 30; 1055 } 1056 1057 TEST_F(GCMChannelStatusSyncerTest, DisableAndEnable) { 1058 // Create GCMDriver first. GCM is not started. 1059 CreateDriver(FakeGCMClient::NO_DELAY_START); 1060 EXPECT_FALSE(driver()->IsStarted()); 1061 1062 // By default, GCM is enabled. 1063 EXPECT_TRUE(driver()->gcm_enabled()); 1064 EXPECT_TRUE(syncer()->gcm_enabled()); 1065 1066 // Remove delay such that the request could be executed immediately. 1067 syncer()->set_delay_removed_for_testing(true); 1068 1069 // GCM will be started after app handler is added. 1070 AddAppHandlers(); 1071 EXPECT_TRUE(driver()->IsStarted()); 1072 1073 // GCM is still enabled at this point. 1074 EXPECT_TRUE(driver()->gcm_enabled()); 1075 EXPECT_TRUE(syncer()->gcm_enabled()); 1076 1077 // Wait until the GCM channel status request gets triggered. 1078 PumpUILoop(); 1079 1080 // Complete the request that disables the GCM. 1081 CompleteGCMChannelStatusRequest(false, 0); 1082 EXPECT_FALSE(driver()->gcm_enabled()); 1083 EXPECT_FALSE(syncer()->gcm_enabled()); 1084 EXPECT_FALSE(driver()->IsStarted()); 1085 1086 // Wait until next GCM channel status request gets triggered. 1087 PumpUILoop(); 1088 1089 // Complete the request that enables the GCM. 1090 CompleteGCMChannelStatusRequest(true, 0); 1091 EXPECT_TRUE(driver()->gcm_enabled()); 1092 EXPECT_TRUE(syncer()->gcm_enabled()); 1093 EXPECT_TRUE(driver()->IsStarted()); 1094 } 1095 1096 TEST_F(GCMChannelStatusSyncerTest, DisableRestartAndEnable) { 1097 // Create GCMDriver first. GCM is not started. 1098 CreateDriver(FakeGCMClient::NO_DELAY_START); 1099 EXPECT_FALSE(driver()->IsStarted()); 1100 1101 // By default, GCM is enabled. 1102 EXPECT_TRUE(driver()->gcm_enabled()); 1103 EXPECT_TRUE(syncer()->gcm_enabled()); 1104 1105 // Remove delay such that the request could be executed immediately. 1106 syncer()->set_delay_removed_for_testing(true); 1107 1108 // GCM will be started after app handler is added. 1109 AddAppHandlers(); 1110 EXPECT_TRUE(driver()->IsStarted()); 1111 1112 // GCM is still enabled at this point. 1113 EXPECT_TRUE(driver()->gcm_enabled()); 1114 EXPECT_TRUE(syncer()->gcm_enabled()); 1115 1116 // Wait until the GCM channel status request gets triggered. 1117 PumpUILoop(); 1118 1119 // Complete the request that disables the GCM. 1120 CompleteGCMChannelStatusRequest(false, 0); 1121 EXPECT_FALSE(driver()->gcm_enabled()); 1122 EXPECT_FALSE(syncer()->gcm_enabled()); 1123 EXPECT_FALSE(driver()->IsStarted()); 1124 1125 // Simulate browser start by recreating GCMDriver. 1126 ShutdownDriver(); 1127 CreateDriver(FakeGCMClient::NO_DELAY_START); 1128 1129 // Remove delay such that the request could be executed immediately. 1130 syncer()->set_delay_removed_for_testing(true); 1131 1132 // GCM is still disabled. 1133 EXPECT_FALSE(driver()->gcm_enabled()); 1134 EXPECT_FALSE(syncer()->gcm_enabled()); 1135 EXPECT_FALSE(driver()->IsStarted()); 1136 1137 AddAppHandlers(); 1138 EXPECT_FALSE(driver()->gcm_enabled()); 1139 EXPECT_FALSE(syncer()->gcm_enabled()); 1140 EXPECT_FALSE(driver()->IsStarted()); 1141 1142 // Wait until the GCM channel status request gets triggered. 1143 PumpUILoop(); 1144 1145 // Complete the request that re-enables the GCM. 1146 CompleteGCMChannelStatusRequest(true, 0); 1147 EXPECT_TRUE(driver()->gcm_enabled()); 1148 EXPECT_TRUE(syncer()->gcm_enabled()); 1149 EXPECT_TRUE(driver()->IsStarted()); 1150 } 1151 1152 TEST_F(GCMChannelStatusSyncerTest, FirstTimePolling) { 1153 // Start GCM. 1154 CreateDriver(FakeGCMClient::NO_DELAY_START); 1155 AddAppHandlers(); 1156 1157 // The 1st request should be triggered shortly without jittering. 1158 EXPECT_EQ(GCMChannelStatusSyncer::first_time_delay_seconds(), 1159 syncer()->current_request_delay_interval().InSeconds()); 1160 } 1161 1162 TEST_F(GCMChannelStatusSyncerTest, SubsequentPollingWithDefaultInterval) { 1163 // Create GCMDriver first. GCM is not started. 1164 CreateDriver(FakeGCMClient::NO_DELAY_START); 1165 1166 // Remove delay such that the request could be executed immediately. 1167 syncer()->set_delay_removed_for_testing(true); 1168 1169 // Now GCM is started. 1170 AddAppHandlers(); 1171 1172 // Wait until the GCM channel status request gets triggered. 1173 PumpUILoop(); 1174 1175 // Keep delay such that we can find out the computed delay time. 1176 syncer()->set_delay_removed_for_testing(false); 1177 1178 // Complete the request. The default interval is intact. 1179 CompleteGCMChannelStatusRequest(true, 0); 1180 1181 // The next request should be scheduled at the expected default interval. 1182 int64 actual_delay_seconds = 1183 syncer()->current_request_delay_interval().InSeconds(); 1184 int64 expected_delay_seconds = 1185 GCMChannelStatusRequest::default_poll_interval_seconds(); 1186 EXPECT_TRUE(CompareDelaySeconds(expected_delay_seconds, actual_delay_seconds)) 1187 << "expected delay: " << expected_delay_seconds 1188 << " actual delay: " << actual_delay_seconds; 1189 1190 // Simulate browser start by recreating GCMDriver. 1191 ShutdownDriver(); 1192 CreateDriver(FakeGCMClient::NO_DELAY_START); 1193 AddAppHandlers(); 1194 1195 // After start-up, the request should still be scheduled at the expected 1196 // default interval. 1197 actual_delay_seconds = 1198 syncer()->current_request_delay_interval().InSeconds(); 1199 EXPECT_TRUE(CompareDelaySeconds(expected_delay_seconds, actual_delay_seconds)) 1200 << "expected delay: " << expected_delay_seconds 1201 << " actual delay: " << actual_delay_seconds; 1202 } 1203 1204 TEST_F(GCMChannelStatusSyncerTest, SubsequentPollingWithUpdatedInterval) { 1205 // Create GCMDriver first. GCM is not started. 1206 CreateDriver(FakeGCMClient::NO_DELAY_START); 1207 1208 // Remove delay such that the request could be executed immediately. 1209 syncer()->set_delay_removed_for_testing(true); 1210 1211 // Now GCM is started. 1212 AddAppHandlers(); 1213 1214 // Wait until the GCM channel status request gets triggered. 1215 PumpUILoop(); 1216 1217 // Keep delay such that we can find out the computed delay time. 1218 syncer()->set_delay_removed_for_testing(false); 1219 1220 // Complete the request. The interval is being changed. 1221 int new_poll_interval_seconds = 1222 GCMChannelStatusRequest::default_poll_interval_seconds() * 2; 1223 CompleteGCMChannelStatusRequest(true, new_poll_interval_seconds); 1224 1225 // The next request should be scheduled at the expected updated interval. 1226 int64 actual_delay_seconds = 1227 syncer()->current_request_delay_interval().InSeconds(); 1228 int64 expected_delay_seconds = new_poll_interval_seconds; 1229 EXPECT_TRUE(CompareDelaySeconds(expected_delay_seconds, actual_delay_seconds)) 1230 << "expected delay: " << expected_delay_seconds 1231 << " actual delay: " << actual_delay_seconds; 1232 1233 // Simulate browser start by recreating GCMDriver. 1234 ShutdownDriver(); 1235 CreateDriver(FakeGCMClient::NO_DELAY_START); 1236 AddAppHandlers(); 1237 1238 // After start-up, the request should still be scheduled at the expected 1239 // updated interval. 1240 actual_delay_seconds = 1241 syncer()->current_request_delay_interval().InSeconds(); 1242 EXPECT_TRUE(CompareDelaySeconds(expected_delay_seconds, actual_delay_seconds)) 1243 << "expected delay: " << expected_delay_seconds 1244 << " actual delay: " << actual_delay_seconds; 1245 } 1246 1247 } // namespace gcm 1248