chrome/browser/services/gcm/gcm_account_tracker.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 "chrome/browser/services/gcm/gcm_account_tracker.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "base/time/time.h"
  11 #include "google_apis/gaia/google_service_auth_error.h"
  12
  13 namespace gcm {
  14
  15 namespace {
  16 const char kGCMGroupServerScope[] = "https://www.googleapis.com/auth/gcm";
  17 const char kGCMCheckinServerScope[] =
  18     "https://www.googleapis.com/auth/android_checkin";
  19 const char kGCMAccountTrackerName[] = "gcm_account_tracker";
  20 }  // namespace
  21
  22 GCMAccountTracker::AccountInfo::AccountInfo(const std::string& email,
  23                                             AccountState state)
  24     : email(email), state(state) {
  25 }
  26
  27 GCMAccountTracker::AccountInfo::~AccountInfo() {
  28 }
  29
  30 GCMAccountTracker::GCMAccountTracker(
  31     scoped_ptr<gaia::AccountTracker> account_tracker,
  32     const UpdateAccountsCallback& callback)
  33     : OAuth2TokenService::Consumer(kGCMAccountTrackerName),
  34       account_tracker_(account_tracker.release()),
  35       callback_(callback),
  36       shutdown_called_(false) {
  37   DCHECK(!callback_.is_null());
  38 }
  39
  40 GCMAccountTracker::~GCMAccountTracker() {
  41   DCHECK(shutdown_called_);
  42 }
  43
  44 void GCMAccountTracker::Shutdown() {
  45   Stop();
  46   shutdown_called_ = true;
  47   account_tracker_->Shutdown();
  48 }
  49
  50 void GCMAccountTracker::Start() {
  51   DCHECK(!shutdown_called_);
  52   account_tracker_->AddObserver(this);
  53
  54   std::vector<gaia::AccountIds> accounts = account_tracker_->GetAccounts();
  55   if (accounts.empty()) {
  56     CompleteCollectingTokens();
  57     return;
  58   }
  59
  60   for (std::vector<gaia::AccountIds>::const_iterator iter = accounts.begin();
  61        iter != accounts.end();
  62        ++iter) {
  63     if (!iter->email.empty()) {
  64       account_infos_.insert(std::make_pair(
  65           iter->account_key, AccountInfo(iter->email, TOKEN_NEEDED)));
  66     }
  67   }
  68
  69   GetAllNeededTokens();
  70 }
  71
  72 void GCMAccountTracker::Stop() {
  73   DCHECK(!shutdown_called_);
  74   account_tracker_->RemoveObserver(this);
  75   pending_token_requests_.clear();
  76 }
  77
  78 void GCMAccountTracker::OnAccountAdded(const gaia::AccountIds& ids) {
  79   DVLOG(1) << "Account added: " << ids.email;
  80   // We listen for the account signing in, which happens after account is added.
  81 }
  82
  83 void GCMAccountTracker::OnAccountRemoved(const gaia::AccountIds& ids) {
  84   DVLOG(1) << "Account removed: " << ids.email;
  85   // We listen for the account signing out, which happens before account is
  86   // removed.
  87 }
  88
  89 void GCMAccountTracker::OnAccountSignInChanged(const gaia::AccountIds& ids,
  90                                                bool is_signed_in) {
  91   if (is_signed_in)
  92     OnAccountSignedIn(ids);
  93   else
  94     OnAccountSignedOut(ids);
  95 }
  96
  97 void GCMAccountTracker::OnGetTokenSuccess(
  98     const OAuth2TokenService::Request* request,
  99     const std::string& access_token,
 100     const base::Time& expiration_time) {
 101   DCHECK(request);
 102   DCHECK(!request->GetAccountId().empty());
 103   DVLOG(1) << "Get token success: " << request->GetAccountId();
 104
 105   AccountInfos::iterator iter = account_infos_.find(request->GetAccountId());
 106   DCHECK(iter != account_infos_.end());
 107   if (iter != account_infos_.end()) {
 108     DCHECK(iter->second.state == GETTING_TOKEN ||
 109            iter->second.state == ACCOUNT_REMOVED);
 110     // If OnAccountSignedOut(..) was called most recently, account is kept in
 111     // ACCOUNT_REMOVED state.
 112     if (iter->second.state == GETTING_TOKEN) {
 113       iter->second.state = TOKEN_PRESENT;
 114       iter->second.access_token = access_token;
 115     }
 116   }
 117
 118   DeleteTokenRequest(request);
 119   CompleteCollectingTokens();
 120 }
 121
 122 void GCMAccountTracker::OnGetTokenFailure(
 123     const OAuth2TokenService::Request* request,
 124     const GoogleServiceAuthError& error) {
 125   DCHECK(request);
 126   DCHECK(!request->GetAccountId().empty());
 127   DVLOG(1) << "Get token failure: " << request->GetAccountId();
 128
 129   AccountInfos::iterator iter = account_infos_.find(request->GetAccountId());
 130   DCHECK(iter != account_infos_.end());
 131   if (iter != account_infos_.end()) {
 132     DCHECK(iter->second.state == GETTING_TOKEN ||
 133            iter->second.state == ACCOUNT_REMOVED);
 134     // If OnAccountSignedOut(..) was called most recently, account is kept in
 135     // ACCOUNT_REMOVED state.
 136     if (iter->second.state == GETTING_TOKEN)
 137       iter->second.state = TOKEN_NEEDED;
 138   }
 139
 140   DeleteTokenRequest(request);
 141   CompleteCollectingTokens();
 142 }
 143
 144 void GCMAccountTracker::CompleteCollectingTokens() {
 145   DCHECK(!callback_.is_null());
 146   // Wait for gaia::AccountTracker to be done with fetching the user info, as
 147   // well as all of the pending token requests from GCMAccountTracker to be done
 148   // before you report the results.
 149   if (!account_tracker_->IsAllUserInfoFetched() ||
 150       !pending_token_requests_.empty()) {
 151     return;
 152   }
 153
 154   bool account_removed = false;
 155   std::map<std::string, std::string> account_tokens;
 156   for (AccountInfos::iterator iter = account_infos_.begin();
 157        iter != account_infos_.end();) {
 158     switch (iter->second.state) {
 159       case ACCOUNT_REMOVED:
 160         // We only mark accounts as removed when there was an account that was
 161         // explicitly signed out.
 162         account_removed = true;
 163         // We also stop tracking the account, now that it will be reported as
 164         // removed.
 165         account_infos_.erase(iter++);
 166         break;
 167
 168       case TOKEN_PRESENT:
 169         account_tokens[iter->second.email] = iter->second.access_token;
 170         ++iter;
 171         break;
 172
 173       case GETTING_TOKEN:
 174         // This should not happen, as we are making a check that there are no
 175         // pending requests above.
 176         NOTREACHED();
 177         ++iter;
 178         break;
 179
 180       case TOKEN_NEEDED:
 181         // We failed to fetch an access token for the account, but it has not
 182         // been signed out (perhaps there is a network issue). We don't report
 183         // it, but next time there is a sign-in change we will update its state.
 184         ++iter;
 185         break;
 186     }
 187   }
 188
 189   // Make sure that there is something to report, otherwise bail out.
 190   if (!account_tokens.empty() || account_removed) {
 191     DVLOG(1) << "Calling callback: " << account_tokens.size();
 192     callback_.Run(account_tokens);
 193   } else {
 194     DVLOG(1) << "No tokens and nothing removed. Skipping callback.";
 195   }
 196 }
 197
 198 void GCMAccountTracker::DeleteTokenRequest(
 199     const OAuth2TokenService::Request* request) {
 200   ScopedVector<OAuth2TokenService::Request>::iterator iter = std::find(
 201       pending_token_requests_.begin(), pending_token_requests_.end(), request);
 202   if (iter != pending_token_requests_.end())
 203     pending_token_requests_.erase(iter);
 204 }
 205
 206 void GCMAccountTracker::GetAllNeededTokens() {
 207   for (AccountInfos::iterator iter = account_infos_.begin();
 208        iter != account_infos_.end();
 209        ++iter) {
 210     if (iter->second.state == TOKEN_NEEDED)
 211       GetToken(iter);
 212   }
 213 }
 214
 215 void GCMAccountTracker::GetToken(AccountInfos::iterator& account_iter) {
 216   DCHECK(GetTokenService());
 217   DCHECK_EQ(account_iter->second.state, TOKEN_NEEDED);
 218
 219   OAuth2TokenService::ScopeSet scopes;
 220   scopes.insert(kGCMGroupServerScope);
 221   scopes.insert(kGCMCheckinServerScope);
 222   scoped_ptr<OAuth2TokenService::Request> request =
 223       GetTokenService()->StartRequest(account_iter->first, scopes, this);
 224
 225   pending_token_requests_.push_back(request.release());
 226   account_iter->second.state = GETTING_TOKEN;
 227 }
 228
 229 void GCMAccountTracker::OnAccountSignedIn(const gaia::AccountIds& ids) {
 230   DVLOG(1) << "Account signed in: " << ids.email;
 231   AccountInfos::iterator iter = account_infos_.find(ids.account_key);
 232   if (iter == account_infos_.end()) {
 233     DCHECK(!ids.email.empty());
 234     account_infos_.insert(
 235         std::make_pair(ids.account_key, AccountInfo(ids.email, TOKEN_NEEDED)));
 236   } else if (iter->second.state == ACCOUNT_REMOVED) {
 237     iter->second.state = TOKEN_NEEDED;
 238   }
 239
 240   GetAllNeededTokens();
 241 }
 242
 243 void GCMAccountTracker::OnAccountSignedOut(const gaia::AccountIds& ids) {
 244   DVLOG(1) << "Account signed out: " << ids.email;
 245   AccountInfos::iterator iter = account_infos_.find(ids.account_key);
 246   if (iter == account_infos_.end())
 247     return;
 248
 249   iter->second.access_token.clear();
 250   iter->second.state = ACCOUNT_REMOVED;
 251   CompleteCollectingTokens();
 252 }
 253
 254 OAuth2TokenService* GCMAccountTracker::GetTokenService() {
 255   DCHECK(account_tracker_->identity_provider());
 256   return account_tracker_->identity_provider()->GetTokenService();
 257 }
 258
 259 }  // namespace gcm