components/gcm_driver/gcm_driver_desktop_unittest.cc

   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@example.com";
  41 const char kTestAccountID2[] = "user2@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   ~FakeGCMConnectionObserver() override;
  50
  51   // gcm::GCMConnectionObserver implementation:
  52   void OnConnected(const net::IPEndPoint& ip_endpoint) override;
  53   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   ~GCMDriverTest() override;
 103
 104   // testing::Test:
 105   void SetUp() override;
 106   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   ~GCMDriverFunctionalTest() override;
 685
 686   // GCMDriverTest:
 687   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, sender_ids, GCMDriverTest::DO_NOT_WAIT);
 829
 830   // Test that unregistration fails with async operation pending when there is a
 831   // registration already in progress.
 832   Unregister(kTestAppID1, GCMDriverTest::WAIT);
 833   EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
 834             unregistration_result());
 835
 836   // Complete the unregistration.
 837   WaitForAsyncOperation();
 838   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 839
 840   // Start unregistration without waiting for it to complete. This time no async
 841   // operation is pending.
 842   Unregister(kTestAppID1, GCMDriverTest::DO_NOT_WAIT);
 843
 844   // Test that unregistration fails with async operation pending when there is
 845   // an unregistration already in progress.
 846   Unregister(kTestAppID1, GCMDriverTest::WAIT);
 847   EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
 848             unregistration_result());
 849   ClearResults();
 850
 851   // Complete unregistration.
 852   WaitForAsyncOperation();
 853   EXPECT_EQ(GCMClient::SUCCESS, unregistration_result());
 854 }
 855
 856 TEST_F(GCMDriverFunctionalTest, RegisterWhenAsyncOperationPending) {
 857   std::vector<std::string> sender_ids;
 858   sender_ids.push_back("sender1");
 859   // First start registration without waiting for it to complete.
 860   Register(kTestAppID1, sender_ids, GCMDriverTest::DO_NOT_WAIT);
 861
 862   // Test that registration fails with async operation pending when there is a
 863   // registration already in progress.
 864   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
 865   EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
 866             registration_result());
 867   ClearResults();
 868
 869   // Complete the registration.
 870   WaitForAsyncOperation();
 871   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 872 }
 873
 874 TEST_F(GCMDriverFunctionalTest, RegisterAfterUnfinishedUnregister) {
 875   // Register and wait for it to complete.
 876   std::vector<std::string> sender_ids;
 877   sender_ids.push_back("sender1");
 878   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
 879   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 880   EXPECT_EQ(GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids),
 881             registration_id());
 882
 883   // Clears the results the would be set by the Register callback in preparation
 884   // to call register 2nd time.
 885   ClearResults();
 886
 887   // Start unregistration without waiting for it to complete.
 888   Unregister(kTestAppID1, GCMDriverTest::DO_NOT_WAIT);
 889
 890   // Register immeidately after unregistration is not completed.
 891   sender_ids.push_back("sender2");
 892   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
 893
 894   // We need one more waiting since the waiting in Register is indeed for
 895   // uncompleted Unregister.
 896   WaitForAsyncOperation();
 897   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 898   EXPECT_EQ(GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids),
 899             registration_id());
 900 }
 901
 902 TEST_F(GCMDriverFunctionalTest, Send) {
 903   GCMClient::OutgoingMessage message;
 904   message.id = "1@ack";
 905   message.data["key1"] = "value1";
 906   message.data["key2"] = "value2";
 907   Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT);
 908
 909   EXPECT_EQ(message.id, send_message_id());
 910   EXPECT_EQ(GCMClient::SUCCESS, send_result());
 911
 912   gcm_app_handler()->WaitForNotification();
 913   EXPECT_EQ(message.id, gcm_app_handler()->acked_message_id());
 914   EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id());
 915 }
 916
 917 TEST_F(GCMDriverFunctionalTest, SendAfterSignOut) {
 918   SignOut();
 919
 920   GCMClient::OutgoingMessage message;
 921   message.id = "1";
 922   message.data["key1"] = "value1";
 923   message.data["key2"] = "value2";
 924   Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT);
 925
 926   EXPECT_TRUE(send_message_id().empty());
 927   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, send_result());
 928 }
 929
 930 TEST_F(GCMDriverFunctionalTest, SendError) {
 931   GCMClient::OutgoingMessage message;
 932   // Embedding error in id will tell the mock to simulate the send error.
 933   message.id = "1@error";
 934   message.data["key1"] = "value1";
 935   message.data["key2"] = "value2";
 936   Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT);
 937
 938   EXPECT_EQ(message.id, send_message_id());
 939   EXPECT_EQ(GCMClient::SUCCESS, send_result());
 940
 941   // Wait for the send error.
 942   gcm_app_handler()->WaitForNotification();
 943   EXPECT_EQ(FakeGCMAppHandler::SEND_ERROR_EVENT,
 944             gcm_app_handler()->received_event());
 945   EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id());
 946   EXPECT_EQ(message.id,
 947             gcm_app_handler()->send_error_details().message_id);
 948   EXPECT_NE(GCMClient::SUCCESS,
 949             gcm_app_handler()->send_error_details().result);
 950   EXPECT_EQ(message.data,
 951             gcm_app_handler()->send_error_details().additional_data);
 952 }
 953
 954 TEST_F(GCMDriverFunctionalTest, MessageReceived) {
 955   Register(kTestAppID1, ToSenderList("sender"), GCMDriverTest::WAIT);
 956   GCMClient::IncomingMessage message;
 957   message.data["key1"] = "value1";
 958   message.data["key2"] = "value2";
 959   message.sender_id = "sender";
 960   GetGCMClient()->ReceiveMessage(kTestAppID1, message);
 961   gcm_app_handler()->WaitForNotification();
 962   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
 963             gcm_app_handler()->received_event());
 964   EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id());
 965   EXPECT_EQ(message.data, gcm_app_handler()->message().data);
 966   EXPECT_TRUE(gcm_app_handler()->message().collapse_key.empty());
 967   EXPECT_EQ(message.sender_id, gcm_app_handler()->message().sender_id);
 968 }
 969
 970 TEST_F(GCMDriverFunctionalTest, MessageWithCollapseKeyReceived) {
 971   Register(kTestAppID1, ToSenderList("sender"), GCMDriverTest::WAIT);
 972   GCMClient::IncomingMessage message;
 973   message.data["key1"] = "value1";
 974   message.collapse_key = "collapse_key_value";
 975   message.sender_id = "sender";
 976   GetGCMClient()->ReceiveMessage(kTestAppID1, message);
 977   gcm_app_handler()->WaitForNotification();
 978   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
 979             gcm_app_handler()->received_event());
 980   EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id());
 981   EXPECT_EQ(message.data, gcm_app_handler()->message().data);
 982   EXPECT_EQ(message.collapse_key,
 983             gcm_app_handler()->message().collapse_key);
 984 }
 985
 986 TEST_F(GCMDriverFunctionalTest, MessagesDeleted) {
 987   GetGCMClient()->DeleteMessages(kTestAppID1);
 988   gcm_app_handler()->WaitForNotification();
 989   EXPECT_EQ(FakeGCMAppHandler::MESSAGES_DELETED_EVENT,
 990             gcm_app_handler()->received_event());
 991   EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id());
 992 }
 993
 994 TEST_F(GCMDriverFunctionalTest, LastTokenFetchTime) {
 995   EXPECT_EQ(base::Time(), driver()->GetLastTokenFetchTime());
 996   base::Time fetch_time = base::Time::Now();
 997   driver()->SetLastTokenFetchTime(fetch_time);
 998   EXPECT_EQ(fetch_time, driver()->GetLastTokenFetchTime());
 999 }
1000
1001 // Tests a single instance of GCMDriver.
1002 class GCMChannelStatusSyncerTest : public GCMDriverTest {
1003  public:
1004   GCMChannelStatusSyncerTest();
1005   ~GCMChannelStatusSyncerTest() override;
1006
1007   // testing::Test:
1008   void SetUp() override;
1009
1010   void CompleteGCMChannelStatusRequest(bool enabled, int poll_interval_seconds);
1011   bool CompareDelaySeconds(int64 expected_delay_seconds,
1012                            int64 actual_delay_seconds);
1013
1014   GCMChannelStatusSyncer* syncer() {
1015     return driver()->gcm_channel_status_syncer_for_testing();
1016   }
1017
1018  private:
1019   net::TestURLFetcherFactory url_fetcher_factory_;
1020
1021   DISALLOW_COPY_AND_ASSIGN(GCMChannelStatusSyncerTest);
1022 };
1023
1024 GCMChannelStatusSyncerTest::GCMChannelStatusSyncerTest() {
1025 }
1026
1027 GCMChannelStatusSyncerTest::~GCMChannelStatusSyncerTest() {
1028 }
1029
1030 void GCMChannelStatusSyncerTest::SetUp() {
1031   GCMDriverTest::SetUp();
1032
1033   url_fetcher_factory_.set_remove_fetcher_on_delete(true);
1034
1035   // Turn on all-user support.
1036   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("GCM", "Enabled"));
1037 }
1038
1039 void GCMChannelStatusSyncerTest::CompleteGCMChannelStatusRequest(
1040     bool enabled, int poll_interval_seconds) {
1041   sync_pb::ExperimentStatusResponse response_proto;
1042   sync_pb::ExperimentsSpecifics* experiment_specifics =
1043       response_proto.add_experiment();
1044   experiment_specifics->mutable_gcm_channel()->set_enabled(enabled);
1045
1046   if (poll_interval_seconds)
1047     response_proto.set_poll_interval_seconds(poll_interval_seconds);
1048
1049   std::string response_string;
1050   response_proto.SerializeToString(&response_string);
1051
1052   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
1053   ASSERT_TRUE(fetcher);
1054   fetcher->set_response_code(net::HTTP_OK);
1055   fetcher->SetResponseString(response_string);
1056   fetcher->delegate()->OnURLFetchComplete(fetcher);
1057 }
1058
1059 bool GCMChannelStatusSyncerTest::CompareDelaySeconds(
1060     int64 expected_delay_seconds, int64 actual_delay_seconds) {
1061   // Most of time, the actual delay should not be smaller than the expected
1062   // delay.
1063   if (actual_delay_seconds >= expected_delay_seconds)
1064     return true;
1065   // It is also OK that the actual delay is a bit smaller than the expected
1066   // delay in case that the test runs slowly.
1067   return expected_delay_seconds - actual_delay_seconds < 30;
1068 }
1069
1070 TEST_F(GCMChannelStatusSyncerTest, DisableAndEnable) {
1071   // Create GCMDriver first. GCM is not started.
1072   CreateDriver(FakeGCMClient::NO_DELAY_START);
1073   EXPECT_FALSE(driver()->IsStarted());
1074
1075   // By default, GCM is enabled.
1076   EXPECT_TRUE(driver()->gcm_enabled());
1077   EXPECT_TRUE(syncer()->gcm_enabled());
1078
1079   // Remove delay such that the request could be executed immediately.
1080   syncer()->set_delay_removed_for_testing(true);
1081
1082   // GCM will be started after app handler is added.
1083   AddAppHandlers();
1084   EXPECT_TRUE(driver()->IsStarted());
1085
1086   // GCM is still enabled at this point.
1087   EXPECT_TRUE(driver()->gcm_enabled());
1088   EXPECT_TRUE(syncer()->gcm_enabled());
1089
1090   // Wait until the GCM channel status request gets triggered.
1091   PumpUILoop();
1092
1093   // Complete the request that disables the GCM.
1094   CompleteGCMChannelStatusRequest(false, 0);
1095   EXPECT_FALSE(driver()->gcm_enabled());
1096   EXPECT_FALSE(syncer()->gcm_enabled());
1097   EXPECT_FALSE(driver()->IsStarted());
1098
1099   // Wait until next GCM channel status request gets triggered.
1100   PumpUILoop();
1101
1102   // Complete the request that enables the GCM.
1103   CompleteGCMChannelStatusRequest(true, 0);
1104   EXPECT_TRUE(driver()->gcm_enabled());
1105   EXPECT_TRUE(syncer()->gcm_enabled());
1106   EXPECT_TRUE(driver()->IsStarted());
1107 }
1108
1109 TEST_F(GCMChannelStatusSyncerTest, DisableRestartAndEnable) {
1110   // Create GCMDriver first. GCM is not started.
1111   CreateDriver(FakeGCMClient::NO_DELAY_START);
1112   EXPECT_FALSE(driver()->IsStarted());
1113
1114   // By default, GCM is enabled.
1115   EXPECT_TRUE(driver()->gcm_enabled());
1116   EXPECT_TRUE(syncer()->gcm_enabled());
1117
1118   // Remove delay such that the request could be executed immediately.
1119   syncer()->set_delay_removed_for_testing(true);
1120
1121   // GCM will be started after app handler is added.
1122   AddAppHandlers();
1123   EXPECT_TRUE(driver()->IsStarted());
1124
1125   // GCM is still enabled at this point.
1126   EXPECT_TRUE(driver()->gcm_enabled());
1127   EXPECT_TRUE(syncer()->gcm_enabled());
1128
1129   // Wait until the GCM channel status request gets triggered.
1130   PumpUILoop();
1131
1132   // Complete the request that disables the GCM.
1133   CompleteGCMChannelStatusRequest(false, 0);
1134   EXPECT_FALSE(driver()->gcm_enabled());
1135   EXPECT_FALSE(syncer()->gcm_enabled());
1136   EXPECT_FALSE(driver()->IsStarted());
1137
1138   // Simulate browser start by recreating GCMDriver.
1139   ShutdownDriver();
1140   CreateDriver(FakeGCMClient::NO_DELAY_START);
1141
1142   // Remove delay such that the request could be executed immediately.
1143   syncer()->set_delay_removed_for_testing(true);
1144
1145   // GCM is still disabled.
1146   EXPECT_FALSE(driver()->gcm_enabled());
1147   EXPECT_FALSE(syncer()->gcm_enabled());
1148   EXPECT_FALSE(driver()->IsStarted());
1149
1150   AddAppHandlers();
1151   EXPECT_FALSE(driver()->gcm_enabled());
1152   EXPECT_FALSE(syncer()->gcm_enabled());
1153   EXPECT_FALSE(driver()->IsStarted());
1154
1155   // Wait until the GCM channel status request gets triggered.
1156   PumpUILoop();
1157
1158   // Complete the request that re-enables the GCM.
1159   CompleteGCMChannelStatusRequest(true, 0);
1160   EXPECT_TRUE(driver()->gcm_enabled());
1161   EXPECT_TRUE(syncer()->gcm_enabled());
1162   EXPECT_TRUE(driver()->IsStarted());
1163 }
1164
1165 TEST_F(GCMChannelStatusSyncerTest, FirstTimePolling) {
1166   // Start GCM.
1167   CreateDriver(FakeGCMClient::NO_DELAY_START);
1168   AddAppHandlers();
1169
1170   // The 1st request should be triggered shortly without jittering.
1171   EXPECT_EQ(GCMChannelStatusSyncer::first_time_delay_seconds(),
1172             syncer()->current_request_delay_interval().InSeconds());
1173 }
1174
1175 TEST_F(GCMChannelStatusSyncerTest, SubsequentPollingWithDefaultInterval) {
1176   // Create GCMDriver first. GCM is not started.
1177   CreateDriver(FakeGCMClient::NO_DELAY_START);
1178
1179   // Remove delay such that the request could be executed immediately.
1180   syncer()->set_delay_removed_for_testing(true);
1181
1182   // Now GCM is started.
1183   AddAppHandlers();
1184
1185   // Wait until the GCM channel status request gets triggered.
1186   PumpUILoop();
1187
1188   // Keep delay such that we can find out the computed delay time.
1189   syncer()->set_delay_removed_for_testing(false);
1190
1191   // Complete the request. The default interval is intact.
1192   CompleteGCMChannelStatusRequest(true, 0);
1193
1194   // The next request should be scheduled at the expected default interval.
1195   int64 actual_delay_seconds =
1196       syncer()->current_request_delay_interval().InSeconds();
1197   int64 expected_delay_seconds =
1198       GCMChannelStatusRequest::default_poll_interval_seconds();
1199   EXPECT_TRUE(CompareDelaySeconds(expected_delay_seconds, actual_delay_seconds))
1200       << "expected delay: " << expected_delay_seconds
1201       << " actual delay: " << actual_delay_seconds;
1202
1203   // Simulate browser start by recreating GCMDriver.
1204   ShutdownDriver();
1205   CreateDriver(FakeGCMClient::NO_DELAY_START);
1206   AddAppHandlers();
1207
1208   // After start-up, the request should still be scheduled at the expected
1209   // default interval.
1210   actual_delay_seconds =
1211       syncer()->current_request_delay_interval().InSeconds();
1212   EXPECT_TRUE(CompareDelaySeconds(expected_delay_seconds, actual_delay_seconds))
1213       << "expected delay: " << expected_delay_seconds
1214       << " actual delay: " << actual_delay_seconds;
1215 }
1216
1217 TEST_F(GCMChannelStatusSyncerTest, SubsequentPollingWithUpdatedInterval) {
1218   // Create GCMDriver first. GCM is not started.
1219   CreateDriver(FakeGCMClient::NO_DELAY_START);
1220
1221   // Remove delay such that the request could be executed immediately.
1222   syncer()->set_delay_removed_for_testing(true);
1223
1224   // Now GCM is started.
1225   AddAppHandlers();
1226
1227   // Wait until the GCM channel status request gets triggered.
1228   PumpUILoop();
1229
1230   // Keep delay such that we can find out the computed delay time.
1231   syncer()->set_delay_removed_for_testing(false);
1232
1233   // Complete the request. The interval is being changed.
1234   int new_poll_interval_seconds =
1235       GCMChannelStatusRequest::default_poll_interval_seconds() * 2;
1236   CompleteGCMChannelStatusRequest(true, new_poll_interval_seconds);
1237
1238   // The next request should be scheduled at the expected updated interval.
1239   int64 actual_delay_seconds =
1240       syncer()->current_request_delay_interval().InSeconds();
1241   int64 expected_delay_seconds = new_poll_interval_seconds;
1242   EXPECT_TRUE(CompareDelaySeconds(expected_delay_seconds, actual_delay_seconds))
1243       << "expected delay: " << expected_delay_seconds
1244       << " actual delay: " << actual_delay_seconds;
1245
1246   // Simulate browser start by recreating GCMDriver.
1247   ShutdownDriver();
1248   CreateDriver(FakeGCMClient::NO_DELAY_START);
1249   AddAppHandlers();
1250
1251   // After start-up, the request should still be scheduled at the expected
1252   // updated interval.
1253   actual_delay_seconds =
1254       syncer()->current_request_delay_interval().InSeconds();
1255   EXPECT_TRUE(CompareDelaySeconds(expected_delay_seconds, actual_delay_seconds))
1256       << "expected delay: " << expected_delay_seconds
1257       << " actual delay: " << actual_delay_seconds;
1258 }
1259
1260 }  // namespace gcm