[GCM] Adding last token fetching time handling

components/gcm_driver/gcm_client_impl_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/gcm_driver/gcm_client_impl.h"
 
 #include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 222 matching lines @@
 }  // namespace
 
 class GCMClientImplTest : public testing::Test,
                           public GCMClient::Delegate {
  public:
   GCMClientImplTest();
   virtual ~GCMClientImplTest();
 
   virtual void SetUp() override;
 
+  void SetUpUrlFetcherFactory();
+
   void BuildGCMClient(base::TimeDelta clock_step);
   void InitializeGCMClient();
   void StartGCMClient();
   void ReceiveMessageFromMCS(const MCSMessage& message);
   void ReceiveOnMessageSentToMCS(
       const std::string& app_id,
       const std::string& message_id,
       const MCSClient::MessageSendStatus status);
   void CompleteCheckin(uint64 android_id,
                        uint64 security_token,
@@ skipping 18 matching lines @@
                       const std::string& message_id,
                       GCMClient::Result result) override {}
   void OnMessageReceived(const std::string& registration_id,
                          const GCMClient::IncomingMessage& message) override;
   void OnMessagesDeleted(const std::string& app_id) override;
   void OnMessageSendError(
       const std::string& app_id,
       const gcm::GCMClient::SendErrorDetails& send_error_details) override;
   void OnSendAcknowledged(const std::string& app_id,
                           const std::string& message_id) override;
-  void OnGCMReady(const std::vector<AccountMapping>& account_mappings) override;
+  void OnGCMReady(const std::vector<AccountMapping>& account_mappings,
+                  const base::Time& last_token_fetch_time) override;
   void OnActivityRecorded() override {}
   void OnConnected(const net::IPEndPoint& ip_endpoint) override {}
   void OnDisconnected() override {}
 
   GCMClientImpl* gcm_client() const { return gcm_client_.get(); }
   FakeMCSClient* mcs_client() const {
     return reinterpret_cast<FakeMCSClient*>(gcm_client_->mcs_client_.get());
   }
   ConnectionFactory* connection_factory() const {
     return gcm_client_->connection_factory_.get();
   }
 
   const GCMClientImpl::CheckinInfo& device_checkin_info() const {
     return gcm_client_->device_checkin_info_;
   }
 
   void reset_last_event() {
     last_event_ = NONE;
     last_app_id_.clear();
     last_registration_id_.clear();
     last_message_id_.clear();
     last_result_ = GCMClient::UNKNOWN_ERROR;
+    last_account_mappings_.clear();
+    last_token_fetch_time_ = base::Time();
   }
 
   LastEvent last_event() const { return last_event_; }
   const std::string& last_app_id() const { return last_app_id_; }
   const std::string& last_registration_id() const {
     return last_registration_id_;
   }
   const std::string& last_message_id() const { return last_message_id_; }
   GCMClient::Result last_result() const { return last_result_; }
   const GCMClient::IncomingMessage& last_message() const {
     return last_message_;
   }
   const GCMClient::SendErrorDetails& last_error_details() const {
     return last_error_details_;
   }
+  const base::Time& last_token_fetch_time() const {
+    return last_token_fetch_time_;
+  }
+  const std::vector<AccountMapping>& last_account_mappings() {
+    return last_account_mappings_;
+  }
 
   const GServicesSettings& gservices_settings() const {
     return gcm_client_->gservices_settings_;
   }
 
   int64 CurrentTime();
 
   // Tooling.
   void PumpLoop();
   void PumpLoopUntilIdle();
   void QuitLoop();
   void InitializeLoop();
   bool CreateUniqueTempDir();
   AutoAdvancingTestClock* clock() const {
     return reinterpret_cast<AutoAdvancingTestClock*>(gcm_client_->clock_.get());
   }
 
  private:
   // Variables used for verification.
   LastEvent last_event_;
   std::string last_app_id_;
   std::string last_registration_id_;
   std::string last_message_id_;
   GCMClient::Result last_result_;
   GCMClient::IncomingMessage last_message_;
   GCMClient::SendErrorDetails last_error_details_;
+  base::Time last_token_fetch_time_;
+  std::vector<AccountMapping> last_account_mappings_;
 
   scoped_ptr<GCMClientImpl> gcm_client_;
 
   base::MessageLoop message_loop_;
   scoped_ptr<base::RunLoop> run_loop_;
   net::TestURLFetcherFactory url_fetcher_factory_;
 
   // Injected to GCM client:
   base::ScopedTempDir temp_directory_;
   scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_;
 };
 
 GCMClientImplTest::GCMClientImplTest()
     : last_event_(NONE),
       last_result_(GCMClient::UNKNOWN_ERROR),
       url_request_context_getter_(new net::TestURLRequestContextGetter(
           message_loop_.message_loop_proxy())) {
 }
 
 GCMClientImplTest::~GCMClientImplTest() {}
 
 void GCMClientImplTest::SetUp() {
   testing::Test::SetUp();
   ASSERT_TRUE(CreateUniqueTempDir());
   InitializeLoop();
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
   StartGCMClient();
-  url_fetcher_factory_.set_remove_fetcher_on_delete(true);
+  SetUpUrlFetcherFactory();
   CompleteCheckin(kDeviceAndroidId,
                   kDeviceSecurityToken,
                   std::string(),
                   std::map<std::string, std::string>());
 }
 
+void GCMClientImplTest::SetUpUrlFetcherFactory() {
+  url_fetcher_factory_.set_remove_fetcher_on_delete(true);
+}
+
 void GCMClientImplTest::PumpLoop() {
   run_loop_->Run();
   run_loop_.reset(new base::RunLoop());
 }
 
 void GCMClientImplTest::PumpLoopUntilIdle() {
   run_loop_->RunUntilIdle();
   run_loop_.reset(new base::RunLoop());
 }
 
@@ skipping 117 matching lines @@
 }
 
 void GCMClientImplTest::ReceiveOnMessageSentToMCS(
       const std::string& app_id,
       const std::string& message_id,
       const MCSClient::MessageSendStatus status) {
   gcm_client_->OnMessageSentToMCS(0LL, app_id, message_id, status);
 }
 
 void GCMClientImplTest::OnGCMReady(
-    const std::vector<AccountMapping>& account_mappings) {
+    const std::vector<AccountMapping>& account_mappings,
+    const base::Time& last_token_fetch_time) {
   last_event_ = LOADING_COMPLETED;
+  last_account_mappings_ = account_mappings;
+  last_token_fetch_time_ = last_token_fetch_time;
   QuitLoop();
-  // TODO(fgorski): Add scenario verifying contents of account_mappings, when
-  // the list is not empty.
 }
 
 void GCMClientImplTest::OnMessageReceived(
     const std::string& registration_id,
     const GCMClient::IncomingMessage& message) {
   last_event_ = MESSAGE_RECEIVED;
   last_app_id_ = registration_id;
   last_message_ = message;
   QuitLoop();
 }
@@ skipping 461 matching lines @@
   EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
             device_checkin_info().account_tokens);
 }
 
 class GCMClientImplStartAndStopTest : public GCMClientImplTest {
 public:
   GCMClientImplStartAndStopTest();
   virtual ~GCMClientImplStartAndStopTest();
 
   virtual void SetUp() override;
+
+  void DefaultCompleteCheckin();
 };
 
 GCMClientImplStartAndStopTest::GCMClientImplStartAndStopTest() {
 }
 
 GCMClientImplStartAndStopTest::~GCMClientImplStartAndStopTest() {
 }
 
 void GCMClientImplStartAndStopTest::SetUp() {
   testing::Test::SetUp();
   ASSERT_TRUE(CreateUniqueTempDir());
   InitializeLoop();
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
 }
 
+void GCMClientImplStartAndStopTest::DefaultCompleteCheckin() {
+  SetUpUrlFetcherFactory();
+  CompleteCheckin(kDeviceAndroidId,
+                  kDeviceSecurityToken,
+                  std::string(),
+                  std::map<std::string, std::string>());
+  PumpLoopUntilIdle();
+}
+
 TEST_F(GCMClientImplStartAndStopTest, StartStopAndRestart) {
   // Start the GCM and wait until it is ready.
   gcm_client()->Start();
   PumpLoopUntilIdle();
 
   // Stop the GCM.
   gcm_client()->Stop();
   PumpLoopUntilIdle();
 
   // Restart the GCM.
@@ skipping 11 matching lines @@
 
 TEST_F(GCMClientImplStartAndStopTest, StartStopAndRestartImmediately) {
   // Start the GCM and then stop and restart it immediately.
   gcm_client()->Start();
   gcm_client()->Stop();
   gcm_client()->Start();
 
   PumpLoopUntilIdle();
 }
 
+// Test for known account mappings and last token fetching time being passed
+// to OnGCMReady.
+TEST_F(GCMClientImplStartAndStopTest, OnGCMReadyAccountsAndTokenFetchingTime) {
+  // Start the GCM and wait until it is ready.
+  gcm_client()->Start();
+  PumpLoopUntilIdle();
+  DefaultCompleteCheckin();
+
+  base::Time expected_time = base::Time::Now();
+  gcm_client()->SetLastTokenFetchTime(expected_time);
+  AccountMapping expected_mapping;
+  expected_mapping.account_id = "accId";
+  expected_mapping.email = "email@gmail.com";
+  expected_mapping.status = AccountMapping::MAPPED;
+  expected_mapping.status_change_timestamp = expected_time;
+  gcm_client()->UpdateAccountMapping(expected_mapping);
+  PumpLoopUntilIdle();
+
+  // Stop the GCM.
+  gcm_client()->Stop();
+  PumpLoopUntilIdle();
+
+  // Restart the GCM.
+  gcm_client()->Start();
+  PumpLoopUntilIdle();
+
+  EXPECT_EQ(LOADING_COMPLETED, last_event());
+  EXPECT_EQ(expected_time, last_token_fetch_time());
+  ASSERT_EQ(1UL, last_account_mappings().size());
+  const AccountMapping& actual_mapping = last_account_mappings()[0];
+  EXPECT_EQ(expected_mapping.account_id, actual_mapping.account_id);
+  EXPECT_EQ(expected_mapping.email, actual_mapping.email);
+  EXPECT_EQ(expected_mapping.status, actual_mapping.status);
+  EXPECT_EQ(expected_mapping.status_change_timestamp,
+            actual_mapping.status_change_timestamp);
+}
+
 }  // namespace gcm