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

chrome/browser/managed_mode/managed_user_refresh_token_fetcher.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 "chrome/browser/managed_mode/managed_user_refresh_token_fetcher.h"
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ skipping 34 matching lines @@
 
 static const char kCodeKey[] = "code";
 
 class ManagedUserRefreshTokenFetcherImpl
     : public ManagedUserRefreshTokenFetcher,
       public OAuth2TokenService::Consumer,
       public URLFetcherDelegate,
       public GaiaOAuthClient::Delegate {
  public:
   ManagedUserRefreshTokenFetcherImpl(OAuth2TokenService* oauth2_token_service,
-                              URLRequestContextGetter* context);
+                                     const std::string& account_id,
+                                     URLRequestContextGetter* context);
   virtual ~ManagedUserRefreshTokenFetcherImpl();
 
   // ManagedUserRefreshTokenFetcher implementation:
   virtual void Start(const std::string& managed_user_id,
                      const std::string& device_name,
                      const TokenCallback& callback) OVERRIDE;
 
  protected:
   // OAuth2TokenService::Consumer implementation:
   virtual void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
@@ skipping 16 matching lines @@
 
  private:
   // Requests an access token, which is the first thing we need. This is where
   // we restart when the returned access token has expired.
   void StartFetching();
 
   void DispatchNetworkError(int error_code);
   void DispatchGoogleServiceAuthError(const GoogleServiceAuthError& error,
                                       const std::string& token);
   OAuth2TokenService* oauth2_token_service_;
+  std::string account_id_;
   URLRequestContextGetter* context_;
 
   std::string device_name_;
   std::string managed_user_id_;
   TokenCallback callback_;
 
   scoped_ptr<OAuth2TokenService::Request> access_token_request_;
   std::string access_token_;
   bool access_token_expired_;
   scoped_ptr<URLFetcher> url_fetcher_;
   scoped_ptr<GaiaOAuthClient> gaia_oauth_client_;
 };
 
 ManagedUserRefreshTokenFetcherImpl::ManagedUserRefreshTokenFetcherImpl(
     OAuth2TokenService* oauth2_token_service,
+    const std::string& account_id,
     URLRequestContextGetter* context)
     : oauth2_token_service_(oauth2_token_service),
+      account_id_(account_id),
       context_(context),
       access_token_expired_(false) {}
 
 ManagedUserRefreshTokenFetcherImpl::~ManagedUserRefreshTokenFetcherImpl() {}
 
 void ManagedUserRefreshTokenFetcherImpl::Start(
     const std::string& managed_user_id,
     const std::string& device_name,
     const TokenCallback& callback) {
   DCHECK(callback_.is_null());
   managed_user_id_ = managed_user_id;
   device_name_ = device_name;
   callback_ = callback;
   StartFetching();
 }
 
 void ManagedUserRefreshTokenFetcherImpl::StartFetching() {
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(GaiaUrls::GetInstance()->oauth1_login_scope());
-  access_token_request_ = oauth2_token_service_->StartRequest(scopes, this);
+  access_token_request_ = oauth2_token_service_->StartRequest(
+      account_id_, scopes, this);
 }
 
 void ManagedUserRefreshTokenFetcherImpl::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const Time& expiration_time) {
   DCHECK_EQ(access_token_request_.get(), request);
   access_token_ = access_token;
 
   GURL url(GaiaUrls::GetInstance()->oauth2_issue_token_url());
@@ skipping 34 matching lines @@
     const URLFetcher* source) {
   const net::URLRequestStatus& status = source->GetStatus();
   if (!status.is_success()) {
     DispatchNetworkError(status.error());
     return;
   }
 
   int response_code = source->GetResponseCode();
   if (response_code == net::HTTP_UNAUTHORIZED && !access_token_expired_) {
     access_token_expired_ = true;
-    oauth2_token_service_->InvalidateToken(OAuth2TokenService::ScopeSet(),
+    oauth2_token_service_->InvalidateToken(account_id_,
+                                           OAuth2TokenService::ScopeSet(),
                                            access_token_);
     StartFetching();
     return;
   }
 
   if (response_code != net::HTTP_OK) {
     // TODO(bauerb): We should return the HTTP response code somehow.
     DLOG(WARNING) << "HTTP error " << response_code;
     DispatchGoogleServiceAuthError(
         GoogleServiceAuthError(GoogleServiceAuthError::CONNECTION_FAILED),
@@ skipping 64 matching lines @@
     const std::string& token) {
   callback_.Run(error, token);
   callback_.Reset();
 }
 
 }  // namespace
 
 // static
 scoped_ptr<ManagedUserRefreshTokenFetcher>
 ManagedUserRefreshTokenFetcher::Create(OAuth2TokenService* oauth2_token_service,
+                                       const std::string& account_id,
                                        URLRequestContextGetter* context) {
   scoped_ptr<ManagedUserRefreshTokenFetcher> fetcher(
-      new ManagedUserRefreshTokenFetcherImpl(oauth2_token_service, context));
+      new ManagedUserRefreshTokenFetcherImpl(oauth2_token_service, account_id,
+          context));
   return fetcher.Pass();
 }
 
 ManagedUserRefreshTokenFetcher::~ManagedUserRefreshTokenFetcher() {}