Making OAuth2TokenService multi-login aware, updating callers, minor fixes

chrome/browser/google_apis/auth_service.cc

 // Copyright (c) 2012 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/google_apis/auth_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 const int kSuccessRatioHistogramFailure = 0;
 const int kSuccessRatioHistogramSuccess = 1;
 const int kSuccessRatioHistogramNoConnection = 2;
 const int kSuccessRatioHistogramTemporaryFailure = 3;
 const int kSuccessRatioHistogramMaxValue = 4;  // The max value is exclusive.
 
 // OAuth2 authorization token retrieval request.
 class AuthRequest : public OAuth2TokenService::Consumer {
  public:
   AuthRequest(OAuth2TokenService* oauth2_token_service,
+              const std::string& account_id,
               net::URLRequestContextGetter* url_request_context_getter,
               const AuthStatusCallback& callback,
               const std::vector<std::string>& scopes);
   virtual ~AuthRequest();
 
  private:
   // Overridden from OAuth2TokenService::Consumer:
   virtual void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
                                  const std::string& access_token,
                                  const base::Time& expiration_time) OVERRIDE;
   virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
                                  const GoogleServiceAuthError& error) OVERRIDE;
 
   AuthStatusCallback callback_;
   scoped_ptr<OAuth2TokenService::Request> request_;
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(AuthRequest);
 };
 
 AuthRequest::AuthRequest(
     OAuth2TokenService* oauth2_token_service,
+    const std::string& account_id,
     net::URLRequestContextGetter* url_request_context_getter,
     const AuthStatusCallback& callback,
     const std::vector<std::string>& scopes)
     : callback_(callback) {
   DCHECK(!callback_.is_null());
   request_ = oauth2_token_service->
       StartRequestWithContext(
+          account_id,
           url_request_context_getter,
           OAuth2TokenService::ScopeSet(scopes.begin(), scopes.end()),
           this);
 }
 
 AuthRequest::~AuthRequest() {}
 
 // Callback for OAuth2AccessTokenFetcher on success. |access_token| is the token
 // used to start fetching user data.
 void AuthRequest::OnGetTokenSuccess(const OAuth2TokenService::Request* request,
@@ skipping 38 matching lines @@
                               kSuccessRatioHistogramMaxValue);
     callback_.Run(HTTP_UNAUTHORIZED, std::string());
   }
   delete this;
 }
 
 }  // namespace
 
 AuthService::AuthService(
     OAuth2TokenService* oauth2_token_service,
+    const std::string& account_id,
     net::URLRequestContextGetter* url_request_context_getter,
     const std::vector<std::string>& scopes)
     : oauth2_token_service_(oauth2_token_service),
+      account_id_(account_id),
       url_request_context_getter_(url_request_context_getter),
       scopes_(scopes),
       weak_ptr_factory_(this) {
   DCHECK(oauth2_token_service);
 
   // Get OAuth2 refresh token (if we have any) and register for its updates.
   oauth2_token_service_->AddObserver(this);
-  has_refresh_token_ = oauth2_token_service_->RefreshTokenIsAvailable();
+  has_refresh_token_ = oauth2_token_service_->RefreshTokenIsAvailable(
+      account_id_);
 }
 
 AuthService::~AuthService() {
   oauth2_token_service_->RemoveObserver(this);
 }
 
 void AuthService::StartAuthentication(const AuthStatusCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scoped_refptr<base::MessageLoopProxy> relay_proxy(
       base::MessageLoopProxy::current());
 
   if (HasAccessToken()) {
     // We already have access token. Give it back to the caller asynchronously.
     relay_proxy->PostTask(FROM_HERE,
                           base::Bind(callback, HTTP_SUCCESS, access_token_));
   } else if (HasRefreshToken()) {
     // We have refresh token, let's get an access token.
     new AuthRequest(oauth2_token_service_,
+                    account_id_,
                     url_request_context_getter_,
                     base::Bind(&AuthService::OnAuthCompleted,
                                weak_ptr_factory_.GetWeakPtr(),
                                callback),
                     scopes_);
   } else {
     relay_proxy->PostTask(FROM_HERE,
                           base::Bind(callback, GDATA_NOT_READY, std::string()));
   }
 }
@@ skipping 64 matching lines @@
 void AuthService::OnHandleRefreshToken(bool has_refresh_token) {
   access_token_.clear();
   has_refresh_token_ = has_refresh_token;
 
   FOR_EACH_OBSERVER(AuthServiceObserver,
                     observers_,
                     OnOAuth2RefreshTokenChanged());
 }
 
 }  // namespace google_apis