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

components/gcm_driver/gcm_client_impl.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/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 229 matching lines @@
       net::NetLog* net_log,
       GCMStatsRecorder* recorder) {
   return make_scoped_ptr<ConnectionFactory>(
       new ConnectionFactoryImpl(endpoints,
                                 backoff_policy,
                                 network_session,
                                 net_log,
                                 recorder));
 }
 
+GCMClientImpl::CheckinInfo::CheckinInfo()
+    : android_id(0), secret(0), accounts_set(false) {
+}
+
+GCMClientImpl::CheckinInfo::~CheckinInfo() {
+}
+
+void GCMClientImpl::CheckinInfo::SnapshotCheckinAccounts() {
+  last_checkin_accounts.clear();
+  for (std::map<std::string, std::string>::iterator iter =
+           account_tokens.begin();
+       iter != account_tokens.end();
+       ++iter) {
+    last_checkin_accounts.insert(iter->first);
+  }
+}
+
+void GCMClientImpl::CheckinInfo::Reset() {
+  android_id = 0;
+  secret = 0;
+  accounts_set = false;
+  account_tokens.clear();
+  last_checkin_accounts.clear();
+}
+
 GCMClientImpl::GCMClientImpl(scoped_ptr<GCMInternalsBuilder> internals_builder)
     : internals_builder_(internals_builder.Pass()),
       state_(UNINITIALIZED),
       delegate_(NULL),
       clock_(internals_builder_->BuildClock()),
       url_request_context_getter_(NULL),
       pending_registration_requests_deleter_(&pending_registration_requests_),
       pending_unregistration_requests_deleter_(
           &pending_unregistration_requests_),
       periodic_checkin_ptr_factory_(this),
@@ skipping 47 matching lines @@
   DCHECK_EQ(LOADING, state_);
 
   if (!result->success) {
     ResetState();
     return;
   }
 
   registrations_ = result->registrations;
   device_checkin_info_.android_id = result->device_android_id;
   device_checkin_info_.secret = result->device_security_token;
+  device_checkin_info_.last_checkin_accounts = result->last_checkin_accounts;
+  // A case where there were previously no accounts reported with checkin is
+  // considered to be the same as when the list of accounts is empty. It enables
+  // scheduling a periodic checkin for devices with no signed in users
+  // immediately after restart, while keeping |accounts_set == false| delays the
+  // checkin until the list of accounts is set explicitly.
+  if (result->last_checkin_accounts.size() == 0)
+    device_checkin_info_.accounts_set = true;
   last_checkin_time_ = result->last_checkin_time;
   gservices_settings_.UpdateFromLoadResult(*result);
   InitializeMCSClient(result.Pass());
 
   if (device_checkin_info_.IsValid()) {
     SchedulePeriodicCheckin();
     OnReady();
     return;
   }
 
@@ skipping 29 matching lines @@
                  weak_ptr_factory_.GetWeakPtr()),
       result.Pass());
 }
 
 void GCMClientImpl::OnFirstTimeDeviceCheckinCompleted(
     const CheckinInfo& checkin_info) {
   DCHECK(!device_checkin_info_.IsValid());
 
   device_checkin_info_.android_id = checkin_info.android_id;
   device_checkin_info_.secret = checkin_info.secret;
+  // If accounts were not set by now, we can consider them set (to empty list)
+  // to make sure periodic checkins get scheduled after initial checkin.
+  device_checkin_info_.accounts_set = true;
   gcm_store_->SetDeviceCredentials(
       checkin_info.android_id, checkin_info.secret,
       base::Bind(&GCMClientImpl::SetDeviceCredentialsCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 
   OnReady();
 }
 
 void GCMClientImpl::OnReady() {
   state_ = READY;
   StartMCSLogin();
 
   delegate_->OnGCMReady();
 }
 
 void GCMClientImpl::StartMCSLogin() {
   DCHECK_EQ(READY, state_);
   DCHECK(device_checkin_info_.IsValid());
   mcs_client_->Login(device_checkin_info_.android_id,
                      device_checkin_info_.secret);
 }
 
 void GCMClientImpl::ResetState() {
   state_ = UNINITIALIZED;
   // TODO(fgorski): reset all of the necessart objects and start over.
 }
 
+void GCMClientImpl::SetAccountsForCheckin(
+    const std::map<std::string, std::string>& account_tokens) {
+  bool accounts_set_before = device_checkin_info_.accounts_set;
+  device_checkin_info_.account_tokens = account_tokens;
+  device_checkin_info_.accounts_set = true;
+
+  DVLOG(1) << "Set account called with: " << account_tokens.size()
+           << " accounts.";
+
+  if (state_ != READY && state_ != INITIAL_DEVICE_CHECKIN)
+    return;
+
+  bool account_removed = false;
+  for (std::set<std::string>::iterator iter =
+           device_checkin_info_.last_checkin_accounts.begin();
+       iter != device_checkin_info_.last_checkin_accounts.end();
+       ++iter) {
+    if (account_tokens.find(*iter) == account_tokens.end())
+      account_removed = true;
+  }
+
+  // Checkin will be forced when any of the accounts was removed during the
+  // current Chrome session or if there has been an account removed between the
+  // restarts of Chrome. If there is a checkin in progress, it will be canceled.

[Nicolas Zea, 2014/07/16 20:53:54]

Comment about why we don't perform a checkin if an account has been added?

[fgorski, 2014/07/17 03:35:35]

Done.

+  if (account_removed) {
+    DVLOG(1) << "Detecting that account has been removed, forcing checkin.";

[Nicolas Zea, 2014/07/16 20:53:54]

nit: Detecting -> Detected

[fgorski, 2014/07/17 03:35:34]

Done.

+    checkin_request_.reset();
+    StartCheckin();
+  } else if (!accounts_set_before) {
+    SchedulePeriodicCheckin();
+    DVLOG(1) << "Scheduled periodic checkin.";
+  }
+}
+
 void GCMClientImpl::StartCheckin() {
   // Make sure no checkin is in progress.
   if (checkin_request_.get())
     return;
 
   checkin_proto::ChromeBuildProto chrome_build_proto;
   ToCheckinProtoVersion(chrome_build_info_, &chrome_build_proto);
   CheckinRequest::RequestInfo request_info(device_checkin_info_.android_id,
                                            device_checkin_info_.secret,
+                                           device_checkin_info_.account_tokens,
                                            gservices_settings_.digest(),
                                            chrome_build_proto);
   checkin_request_.reset(
       new CheckinRequest(gservices_settings_.GetCheckinURL(),
                          request_info,
                          kDefaultBackoffPolicy,
                          base::Bind(&GCMClientImpl::OnCheckinCompleted,
                                     weak_ptr_factory_.GetWeakPtr()),
                          url_request_context_getter_,
                          &recorder_));
+  // Taking a snapshot of the accounts count here, as there might be an asynch
+  // update of the account tokens while checkin is in progress.
+  device_checkin_info_.SnapshotCheckinAccounts();
   checkin_request_->Start();
 }
 
 void GCMClientImpl::OnCheckinCompleted(
     const checkin_proto::AndroidCheckinResponse& checkin_response) {
   checkin_request_.reset();
 
   if (!checkin_response.has_android_id() ||
       !checkin_response.has_security_token()) {
     // TODO(fgorski): I don't think a retry here will help, we should probably
@@ skipping 19 matching lines @@
     // First update G-services settings, as something might have changed.
     if (gservices_settings_.UpdateFromCheckinResponse(checkin_response)) {
       gcm_store_->SetGServicesSettings(
           gservices_settings_.settings_map(),
           gservices_settings_.digest(),
           base::Bind(&GCMClientImpl::SetGServicesSettingsCallback,
                      weak_ptr_factory_.GetWeakPtr()));
     }
 
     last_checkin_time_ = clock_->Now();
-    gcm_store_->SetLastCheckinTime(
+    gcm_store_->SetLastCheckinInfo(
         last_checkin_time_,
-        base::Bind(&GCMClientImpl::SetLastCheckinTimeCallback,
+        device_checkin_info_.last_checkin_accounts,
+        base::Bind(&GCMClientImpl::SetLastCheckinInfoCallback,
                    weak_ptr_factory_.GetWeakPtr()));
     SchedulePeriodicCheckin();
   }
 }
 
 void GCMClientImpl::SetGServicesSettingsCallback(bool success) {
   DCHECK(success);
 }
 
 void GCMClientImpl::SchedulePeriodicCheckin() {
   // Make sure no checkin is in progress.
-  if (checkin_request_.get())
+  if (checkin_request_.get() || !device_checkin_info_.accounts_set)
     return;
 
   // There should be only one periodic checkin pending at a time. Removing
   // pending periodic checkin to schedule a new one.
   periodic_checkin_ptr_factory_.InvalidateWeakPtrs();
 
   base::TimeDelta time_to_next_checkin = GetTimeToNextCheckin();
   if (time_to_next_checkin < base::TimeDelta())
     time_to_next_checkin = base::TimeDelta();
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&GCMClientImpl::StartCheckin,
                  periodic_checkin_ptr_factory_.GetWeakPtr()),
       time_to_next_checkin);
 }
 
 base::TimeDelta GCMClientImpl::GetTimeToNextCheckin() const {
   return last_checkin_time_ + gservices_settings_.GetCheckinInterval() -
          clock_->Now();
 }
 
-void GCMClientImpl::SetLastCheckinTimeCallback(bool success) {
+void GCMClientImpl::SetLastCheckinInfoCallback(bool success) {
   // TODO(fgorski): This is one of the signals that store needs a rebuild.
   DCHECK(success);
 }
 
 void GCMClientImpl::SetDeviceCredentialsCallback(bool success) {
   // TODO(fgorski): This is one of the signals that store needs a rebuild.
   DCHECK(success);
 }
 
 void GCMClientImpl::UpdateRegistrationCallback(bool success) {
@@ skipping 383 matching lines @@
 
   recorder_.RecordIncomingSendError(
       data_message_stanza.category(),
       data_message_stanza.to(),
       data_message_stanza.id());
   delegate_->OnMessageSendError(data_message_stanza.category(),
                                 send_error_details);
 }
 
 }  // namespace gcm