Home | History | Annotate | Download | only in gcm_driver 
      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