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

chrome/browser/services/gcm/gcm_account_tracker.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 "chrome/browser/services/gcm/gcm_account_tracker.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/time/time.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 
 namespace gcm {
 
 namespace {
-const char kGCMGroupServerScope[] =
-    "oauth2:https://www.googleapis.com/auth/gcm";
+const char kGCMGroupServerScope[] = "https://www.googleapis.com/auth/gcm";

[Nicolas Zea, 2014/07/10 20:57:32]

Why is this changing?

[fgorski, 2014/07/11 22:51:20]

I am correcting the scope here, now that I was able to manually test end to end.

 const char kGCMAccountTrackerName[] = "gcm_account_tracker";
 }  // namespace
 
 GCMAccountTracker::AccountInfo::AccountInfo(const std::string& email,
                                             AccountState state)
     : email(email), state(state) {
 }
 
 GCMAccountTracker::AccountInfo::~AccountInfo() {
 }
@@ skipping 40 matching lines @@
   GetAllNeededTokens();
 }
 
 void GCMAccountTracker::Stop() {
   DCHECK(!shutdown_called_);
   account_tracker_->RemoveObserver(this);
   pending_token_requests_.clear();
 }
 
 void GCMAccountTracker::OnAccountAdded(const gaia::AccountIds& ids) {
+  DVLOG(1) << "Account added: " << ids.email;
   // We listen for the account signing in, which happens after account is added.
 }
 
 void GCMAccountTracker::OnAccountRemoved(const gaia::AccountIds& ids) {
+  DVLOG(1) << "Account removed: " << ids.email;
   // We listen for the account signing out, which happens before account is
   // removed.
 }
 
 void GCMAccountTracker::OnAccountSignInChanged(const gaia::AccountIds& ids,
                                                bool is_signed_in) {
   if (is_signed_in)
     OnAccountSignedIn(ids);
   else
     OnAccountSignedOut(ids);
 }
 
 void GCMAccountTracker::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK(request);
   DCHECK(!request->GetAccountId().empty());
+  DVLOG(1) << "Get token success: " << request->GetAccountId();
 
   AccountInfos::iterator iter = account_infos_.find(request->GetAccountId());
   DCHECK(iter != account_infos_.end());
   if (iter != account_infos_.end()) {
     DCHECK(iter->second.state == GETTING_TOKEN ||
            iter->second.state == ACCOUNT_REMOVED);
     // If OnAccountSignedOut(..) was called most recently, account is kept in
     // ACCOUNT_REMOVED state.
     if (iter->second.state == GETTING_TOKEN) {
       iter->second.state = TOKEN_PRESENT;
       iter->second.access_token = access_token;
     }
   }
 
   DeleteTokenRequest(request);
   CompleteCollectingTokens();
 }
 
 void GCMAccountTracker::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DCHECK(request);
   DCHECK(!request->GetAccountId().empty());
+  DVLOG(1) << "Get token failure: " << request->GetAccountId();
 
   AccountInfos::iterator iter = account_infos_.find(request->GetAccountId());
   DCHECK(iter != account_infos_.end());
   if (iter != account_infos_.end()) {
     DCHECK(iter->second.state == GETTING_TOKEN ||
            iter->second.state == ACCOUNT_REMOVED);
     // If OnAccountSignedOut(..) was called most recently, account is kept in
     // ACCOUNT_REMOVED state.
     if (iter->second.state == GETTING_TOKEN)
       iter->second.state = TOKEN_NEEDED;
@@ skipping 41 matching lines @@
 
       case TOKEN_NEEDED:
         // We failed to fetch an access token for the account, but it has not
         // been signed out (perhaps there is a network issue). We don't report
         // it, but next time there is a sign-in change we will update its state.
         ++iter;
         break;
     }
   }
 
-  callback_.Run(account_tokens, account_removed);
+  // Make sure that there is something to report, otherwise bail out.
+  if (!account_tokens.empty() || account_removed) {
+    DVLOG(1) << "Calling callback: " << account_tokens.size() << ", "
+             << (account_removed ? "" : "no ") << "account removed.";
+    callback_.Run(account_tokens, account_removed);
+  } else {
+    DVLOG(1) << "Skipping calling callback.";
+  }
 }
 
 void GCMAccountTracker::DeleteTokenRequest(
     const OAuth2TokenService::Request* request) {
   ScopedVector<OAuth2TokenService::Request>::iterator iter = std::find(
       pending_token_requests_.begin(), pending_token_requests_.end(), request);
   if (iter != pending_token_requests_.end())
     pending_token_requests_.erase(iter);
 }
 
@@ skipping 13 matching lines @@
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(kGCMGroupServerScope);
   scoped_ptr<OAuth2TokenService::Request> request =
       GetTokenService()->StartRequest(account_iter->first, scopes, this);
 
   pending_token_requests_.push_back(request.release());
   account_iter->second.state = GETTING_TOKEN;
 }
 
 void GCMAccountTracker::OnAccountSignedIn(const gaia::AccountIds& ids) {
+  DVLOG(1) << "Account signed in: " << ids.email;
   AccountInfos::iterator iter = account_infos_.find(ids.account_key);
   if (iter == account_infos_.end()) {
     DCHECK(!ids.email.empty());
     account_infos_.insert(
         std::make_pair(ids.account_key, AccountInfo(ids.email, TOKEN_NEEDED)));
   } else if (iter->second.state == ACCOUNT_REMOVED) {
     iter->second.state = TOKEN_NEEDED;
   }
 
   GetAllNeededTokens();
 }
 
 void GCMAccountTracker::OnAccountSignedOut(const gaia::AccountIds& ids) {
+  DVLOG(1) << "Account signed out: " << ids.email;
   AccountInfos::iterator iter = account_infos_.find(ids.account_key);
   if (iter == account_infos_.end())
     return;
 
   iter->second.access_token.clear();
   iter->second.state = ACCOUNT_REMOVED;
   CompleteCollectingTokens();
 }
 
 OAuth2TokenService* GCMAccountTracker::GetTokenService() {
   DCHECK(account_tracker_->identity_provider());
   return account_tracker_->identity_provider()->GetTokenService();
 }
 
 }  // namespace gcm