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

chrome/browser/extensions/api/identity/identity_api.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/extensions/api/identity/identity_api.h"
 
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 202 matching lines @@
   if (type == IdentityMintRequestQueue::MINT_TYPE_NONINTERACTIVE) {
     switch (cache_status) {
       case IdentityTokenCacheValue::CACHE_STATUS_NOTFOUND:
 #if defined(OS_CHROMEOS)
         // Always force minting token for ChromeOS kiosk app.
         if (chromeos::UserManager::Get()->IsLoggedInAsKioskApp()) {
           if (g_browser_process->browser_policy_connector()->
                   IsEnterpriseManaged()) {
             OAuth2TokenService::ScopeSet scope_set(oauth2_info.scopes.begin(),
                                                    oauth2_info.scopes.end());
+            chromeos::DeviceOAuth2TokenService* token_service =
+                chromeos::DeviceOAuth2TokenServiceFactory::Get();
             device_token_request_ =
-                chromeos::DeviceOAuth2TokenServiceFactory::Get()->StartRequest(
-                    scope_set, this);
+                token_service->StartRequest(token_service->GetRobotAccountId(),
+                                            scope_set,
+                                            this);
           } else {
             gaia_mint_token_mode_ = OAuth2MintTokenFlow::MODE_MINT_TOKEN_FORCE;
             StartLoginAccessTokenRequest();
           }
           return;
         }
 #endif
 
         if (oauth2_info.auto_approve)
           // oauth2_info.auto_approve is protected by a whitelist in
@@ skipping 182 matching lines @@
 void IdentityGetAuthTokenFunction::StartLoginAccessTokenRequest() {
   ProfileOAuth2TokenService* service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile());
 #if defined(OS_CHROMEOS)
   if (chrome::IsRunningInForcedAppMode()) {
     std::string app_client_id;
     std::string app_client_secret;
     if (chromeos::UserManager::Get()->GetAppModeChromeClientOAuthInfo(
            &app_client_id, &app_client_secret)) {
       login_token_request_ =
-          service->StartRequestForClient(app_client_id,
+          service->StartRequestForClient(service->GetPrimaryAccountId(),
+                                         app_client_id,
                                          app_client_secret,
                                          OAuth2TokenService::ScopeSet(),
                                          this);
       return;
     }
   }
 #endif
-  login_token_request_ = service->StartRequest(OAuth2TokenService::ScopeSet(),
-                                               this);
+  login_token_request_ = service->StartRequest(
+      service->GetPrimaryAccountId(), OAuth2TokenService::ScopeSet(), this);
 }
 
 void IdentityGetAuthTokenFunction::StartGaiaRequest(
     const std::string& login_access_token) {
   DCHECK(!login_access_token.empty());
   mint_token_flow_.reset(CreateMintTokenFlow(login_access_token));
   mint_token_flow_->Start();
 }
 
 void IdentityGetAuthTokenFunction::ShowLoginPopup() {
@@ skipping 23 matching lines @@
           OAuth2MintTokenFlow::Parameters(
               login_access_token,
               GetExtension()->id(),
               oauth2_client_id_,
               oauth2_info.scopes,
               gaia_mint_token_mode_));
   return mint_token_flow;
 }
 
 bool IdentityGetAuthTokenFunction::HasLoginToken() const {
-  return ProfileOAuth2TokenServiceFactory::GetForProfile(profile())->
-      RefreshTokenIsAvailable();
+  ProfileOAuth2TokenService* token_service =
+      ProfileOAuth2TokenServiceFactory::GetForProfile(profile());
+  return token_service->RefreshTokenIsAvailable(
+      token_service->GetPrimaryAccountId());
 }
 
 std::string IdentityGetAuthTokenFunction::MapOAuth2ErrorToDescription(
     const std::string& error) {
   const char kOAuth2ErrorAccessDenied[] = "access_denied";
   const char kOAuth2ErrorInvalidScope[] = "invalid_scope";
 
   if (error == kOAuth2ErrorAccessDenied)
     return std::string(identity_constants::kUserRejected);
   else if (error == kOAuth2ErrorInvalidScope)
@@ skipping 276 matching lines @@
     const IdentityAPI::TokenCacheKey& rhs) const {
   if (extension_id < rhs.extension_id)
     return true;
   else if (rhs.extension_id < extension_id)
     return false;
 
   return scopes < rhs.scopes;
 }
 
 }  // namespace extensions