Make OAuth2TokenService::Request class multi-login aware.

google_apis/gaia/oauth2_token_service.cc

 // Copyright 2013 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 "google_apis/gaia/oauth2_token_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 29 matching lines @@
 
   if (account_id < p.account_id)
     return true;
   else if (p.account_id < account_id)
     return false;
 
   return scopes < p.scopes;
 }
 
 OAuth2TokenService::RequestImpl::RequestImpl(
+    const std::string& account_id,
     OAuth2TokenService::Consumer* consumer)
-    : consumer_(consumer) {
+    : account_id_(account_id),
+      consumer_(consumer) {
 }
 
 OAuth2TokenService::RequestImpl::~RequestImpl() {
   DCHECK(CalledOnValidThread());
 }
 
+std::string OAuth2TokenService::RequestImpl::GetAccountId() const {
+  return account_id_;
+}
+
 void OAuth2TokenService::RequestImpl::InformConsumer(
     const GoogleServiceAuthError& error,
     const std::string& access_token,
     const base::Time& expiration_date) {
   DCHECK(CalledOnValidThread());
   if (error.state() == GoogleServiceAuthError::NONE)
     consumer_->OnGetTokenSuccess(this, access_token, expiration_date);
   else
     consumer_->OnGetTokenFailure(this, error);
 }
@@ skipping 370 matching lines @@
 scoped_ptr<OAuth2TokenService::Request>
 OAuth2TokenService::StartRequestForClientWithContext(
     const std::string& account_id,
     net::URLRequestContextGetter* getter,
     const std::string& client_id,
     const std::string& client_secret,
     const ScopeSet& scopes,
     Consumer* consumer) {
   DCHECK(CalledOnValidThread());
 
-  scoped_ptr<RequestImpl> request = CreateRequest(consumer);
+  scoped_ptr<RequestImpl> request = CreateRequest(account_id, consumer);
 
   if (!RefreshTokenIsAvailable(account_id)) {
     base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &RequestImpl::InformConsumer,
         request->AsWeakPtr(),
         GoogleServiceAuthError(GoogleServiceAuthError::USER_NOT_SIGNED_UP),
         std::string(),
         base::Time()));
     return request.PassAs<Request>();
   }
 
   RequestParameters request_parameters(client_id,
                                        account_id,
                                        scopes);
   if (HasCacheEntry(request_parameters)) {
     StartCacheLookupRequest(request.get(), request_parameters, consumer);
   } else {
     FetchOAuth2Token(request.get(),
                      account_id,
                      getter,
                      client_id,
                      client_secret,
                      scopes);
   }
   return request.PassAs<Request>();
 }
 
 scoped_ptr<OAuth2TokenService::RequestImpl> OAuth2TokenService::CreateRequest(
+    const std::string& account_id,
     Consumer* consumer) {
-  return scoped_ptr<RequestImpl>(new RequestImpl(consumer));
+  return scoped_ptr<RequestImpl>(new RequestImpl(account_id, consumer));
 }
 
 void OAuth2TokenService::FetchOAuth2Token(RequestImpl* request,
                                           const std::string& account_id,
                                           net::URLRequestContextGetter* getter,
                                           const std::string& client_id,
                                           const std::string& client_secret,
                                           const ScopeSet& scopes) {
   std::string refresh_token = GetRefreshToken(account_id);
 
@@ skipping 244 matching lines @@
     const std::string& account_id,
     const ScopeSet& scopes) const {
   PendingFetcherMap::const_iterator iter = pending_fetchers_.find(
       OAuth2TokenService::RequestParameters(
           client_id,
           account_id,
           scopes));
   return iter == pending_fetchers_.end() ?
              0 : iter->second->GetWaitingRequestCount();
 }