[GCM] Check-in with signed in accounts associates device to user

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/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 244 matching lines @@
   virtual 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;
   }
 
   LastEvent last_event() const { return last_event_; }
   const std::string& last_app_id() const { return last_app_id_; }
@@ skipping 237 matching lines @@
 }
 
 int64 GCMClientImplTest::CurrentTime() {
   return clock()->Now().ToInternalValue() / base::Time::kMicrosecondsPerSecond;
 }
 
 TEST_F(GCMClientImplTest, LoadingCompleted) {
   EXPECT_EQ(LOADING_COMPLETED, last_event());
   EXPECT_EQ(kDeviceAndroidId, mcs_client()->last_android_id());
   EXPECT_EQ(kDeviceSecurityToken, mcs_client()->last_security_token());
+
+  // Checking freshly loaded CheckinInfo.
+  EXPECT_EQ(kDeviceAndroidId, device_checkin_info().android_id);
+  EXPECT_EQ(kDeviceSecurityToken, device_checkin_info().secret);
+  EXPECT_TRUE(device_checkin_info().last_checkin_accounts.empty());
+  EXPECT_TRUE(device_checkin_info().accounts_set);
+  EXPECT_TRUE(device_checkin_info().account_tokens.empty());
 }
 
 TEST_F(GCMClientImplTest, CheckOut) {
   EXPECT_TRUE(mcs_client());
   EXPECT_TRUE(connection_factory());
   gcm_client()->CheckOut();
   EXPECT_FALSE(mcs_client());
   EXPECT_FALSE(connection_factory());
 }
 
@@ skipping 209 matching lines @@
   std::map<std::string, std::string> settings;
   settings["checkin_interval"] = base::IntToString(kSettingsCheckinInterval);
   settings["checkin_url"] = "http://alternative.url/checkin";
   settings["gcm_hostname"] = "alternative.gcm.host";
   settings["gcm_secure_port"] = "7777";
   settings["gcm_registration_url"] = "http://alternative.url/registration";
   CompleteCheckin(kDeviceAndroidId,
                   kDeviceSecurityToken,
                   GServicesSettings::CalculateDigest(settings),
                   settings);
+
   EXPECT_EQ(2, clock()->call_count());
 
   PumpLoopUntilIdle();
   CompleteCheckin(kDeviceAndroidId,
                   kDeviceSecurityToken,
                   GServicesSettings::CalculateDigest(settings),
                   settings);
 }
 
 TEST_F(GCMClientImplCheckinTest, LoadGSettingsFromStore) {
@@ skipping 17 matching lines @@
   EXPECT_EQ(GURL("http://alternative.url/checkin"),
             gservices_settings().GetCheckinURL());
   EXPECT_EQ(GURL("http://alternative.url/registration"),
             gservices_settings().GetRegistrationURL());
   EXPECT_EQ(GURL("https://alternative.gcm.host:7777"),
             gservices_settings().GetMCSMainEndpoint());
   EXPECT_EQ(GURL("https://alternative.gcm.host:443"),
             gservices_settings().GetMCSFallbackEndpoint());
 }
 
+// This test only checks that periodic checkin happens.
+TEST_F(GCMClientImplCheckinTest, CheckinWithAccounts) {
+  std::map<std::string, std::string> settings;
+  settings["checkin_interval"] = base::IntToString(kSettingsCheckinInterval);
+  settings["checkin_url"] = "http://alternative.url/checkin";
+  settings["gcm_hostname"] = "alternative.gcm.host";
+  settings["gcm_secure_port"] = "7777";
+  settings["gcm_registration_url"] = "http://alternative.url/registration";
+  CompleteCheckin(kDeviceAndroidId,
+                  kDeviceSecurityToken,
+                  GServicesSettings::CalculateDigest(settings),
+                  settings);
+
+  std::map<std::string, std::string> account_tokens;
+  account_tokens["test_user1@gmail.com"] = "token1";
+  account_tokens["test_user2@gmail.com"] = "token2";
+  gcm_client()->SetAccountsForCheckin(account_tokens);
+
+  EXPECT_TRUE(device_checkin_info().last_checkin_accounts.empty());
+  EXPECT_TRUE(device_checkin_info().accounts_set);
+  EXPECT_EQ(account_tokens, device_checkin_info().account_tokens);
+
+  PumpLoopUntilIdle();
+  CompleteCheckin(kDeviceAndroidId,
+                  kDeviceSecurityToken,
+                  GServicesSettings::CalculateDigest(settings),
+                  settings);
+
+  std::set<std::string> accounts;
+  accounts.insert("test_user1@gmail.com");
+  accounts.insert("test_user2@gmail.com");
+  EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
+  EXPECT_TRUE(device_checkin_info().accounts_set);
+  EXPECT_EQ(account_tokens, device_checkin_info().account_tokens);
+}
+
+// This test only checks that periodic checkin happens.
+TEST_F(GCMClientImplCheckinTest, CheckinWhenAccountRemoved) {
+  std::map<std::string, std::string> settings;
+  settings["checkin_interval"] = base::IntToString(kSettingsCheckinInterval);
+  settings["checkin_url"] = "http://alternative.url/checkin";
+  settings["gcm_hostname"] = "alternative.gcm.host";
+  settings["gcm_secure_port"] = "7777";
+  settings["gcm_registration_url"] = "http://alternative.url/registration";
+  CompleteCheckin(kDeviceAndroidId,
+                  kDeviceSecurityToken,
+                  GServicesSettings::CalculateDigest(settings),
+                  settings);
+
+  std::map<std::string, std::string> account_tokens;
+  account_tokens["test_user1@gmail.com"] = "token1";
+  account_tokens["test_user2@gmail.com"] = "token2";
+  gcm_client()->SetAccountsForCheckin(account_tokens);
+  PumpLoopUntilIdle();
+  CompleteCheckin(kDeviceAndroidId,
+                  kDeviceSecurityToken,
+                  GServicesSettings::CalculateDigest(settings),
+                  settings);
+
+  EXPECT_EQ(2UL, device_checkin_info().last_checkin_accounts.size());
+  EXPECT_TRUE(device_checkin_info().accounts_set);
+  EXPECT_EQ(account_tokens, device_checkin_info().account_tokens);
+
+  account_tokens.erase(account_tokens.find("test_user2@gmail.com"));
+  gcm_client()->SetAccountsForCheckin(account_tokens);
+
+  PumpLoopUntilIdle();
+  CompleteCheckin(kDeviceAndroidId,
+                  kDeviceSecurityToken,
+                  GServicesSettings::CalculateDigest(settings),
+                  settings);
+
+  std::set<std::string> accounts;
+  accounts.insert("test_user1@gmail.com");
+  EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
+  EXPECT_TRUE(device_checkin_info().accounts_set);
+  EXPECT_EQ(account_tokens, device_checkin_info().account_tokens);
+}
+
+// This test only checks that periodic checkin happens.
+TEST_F(GCMClientImplCheckinTest, CheckinWhenAccountReplaced) {
+  std::map<std::string, std::string> settings;
+  settings["checkin_interval"] = base::IntToString(kSettingsCheckinInterval);
+  settings["checkin_url"] = "http://alternative.url/checkin";
+  settings["gcm_hostname"] = "alternative.gcm.host";
+  settings["gcm_secure_port"] = "7777";
+  settings["gcm_registration_url"] = "http://alternative.url/registration";
+  CompleteCheckin(kDeviceAndroidId,
+                  kDeviceSecurityToken,
+                  GServicesSettings::CalculateDigest(settings),
+                  settings);
+
+  std::map<std::string, std::string> account_tokens;
+  account_tokens["test_user1@gmail.com"] = "token1";
+  gcm_client()->SetAccountsForCheckin(account_tokens);
+
+  PumpLoopUntilIdle();
+  CompleteCheckin(kDeviceAndroidId,
+                  kDeviceSecurityToken,
+                  GServicesSettings::CalculateDigest(settings),
+                  settings);
+
+  std::set<std::string> accounts;
+  accounts.insert("test_user1@gmail.com");
+  EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
+
+  // This should trigger another checkin, because the list of accounts is
+  // different.
+  account_tokens.erase(account_tokens.find("test_user1@gmail.com"));
+  account_tokens["test_user2@gmail.com"] = "token2";
+  gcm_client()->SetAccountsForCheckin(account_tokens);
+
+  PumpLoopUntilIdle();
+  CompleteCheckin(kDeviceAndroidId,
+                  kDeviceSecurityToken,
+                  GServicesSettings::CalculateDigest(settings),
+                  settings);
+
+  accounts.clear();
+  accounts.insert("test_user2@gmail.com");
+  EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
+  EXPECT_TRUE(device_checkin_info().accounts_set);
+  EXPECT_EQ(account_tokens, device_checkin_info().account_tokens);
+}
+
 class GCMClientImplStartAndStopTest : public GCMClientImplTest {
 public:
   GCMClientImplStartAndStopTest();
   virtual ~GCMClientImplStartAndStopTest();
 
   virtual void SetUp() OVERRIDE;
 };
 
 GCMClientImplStartAndStopTest::GCMClientImplStartAndStopTest() {
 }
@@ skipping 34 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();
 }
 
 }  // namespace gcm