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

chrome/browser/chromeos/settings/device_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 "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/cryptohome/cryptohome_library.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 
 namespace {
 const char kServiceScopeGetUserInfo[] =
     "https://www.googleapis.com/auth/userinfo.email";
+const char kDeviceAccountId[] =
+    "device_account_id";
 }  // namespace
 
 namespace chromeos {
 
 // A wrapper for the consumer passed to StartRequest, which doesn't call
 // through to the target Consumer unless the refresh token validation is
 // complete.  Additionally implements the Request interface, so that it
 // can be passed back to the caller and directly deleted when cancelling
 // the request.
 class DeviceOAuth2TokenService::ValidatingConsumer
@@ skipping 72 matching lines @@
   gaia_oauth_client_.reset(new gaia::GaiaOAuthClient(
       g_browser_process->system_request_context()));
 
   GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
   gaia::OAuthClientInfo client_info;
   client_info.client_id = gaia_urls->oauth2_chrome_client_id();
   client_info.client_secret = gaia_urls->oauth2_chrome_client_secret();
 
   gaia_oauth_client_->RefreshToken(
       client_info,
-      token_service_->GetRefreshToken(),
+      token_service_->GetRefreshToken(token_service_->GetDeviceAccountId()),
       std::vector<std::string>(1, kServiceScopeGetUserInfo),
       token_service_->max_refresh_token_validation_retries_,
       this);
 }
 
 void DeviceOAuth2TokenService::ValidatingConsumer::OnRefreshTokenResponse(
     const std::string& access_token,
     int expires_in_seconds) {
   gaia_oauth_client_->GetTokenInfo(
       access_token,
@@ skipping 78 matching lines @@
     consumer_->OnGetTokenSuccess(this, access_token_copy, expiration_time_copy);
   }
 }
 
 DeviceOAuth2TokenService::DeviceOAuth2TokenService(
     net::URLRequestContextGetter* getter,
     PrefService* local_state)
     : refresh_token_is_valid_(false),
       max_refresh_token_validation_retries_(3),
       url_request_context_getter_(getter),
-      local_state_(local_state) {
+      local_state_(local_state),
+      device_account_id_(kDeviceAccountId) {

[Mattias Nissler (ping if slow), 2013/09/06 09:34:48]

I think this is wrong. We do have a proper account ID, which is returned by
GetRobotAccountID(). Please use that instead.

[fgorski, 2013/09/12 23:46:24]

Done.

 }
 
 DeviceOAuth2TokenService::~DeviceOAuth2TokenService() {
 }
 
 scoped_ptr<OAuth2TokenService::Request> DeviceOAuth2TokenService::StartRequest(
+    const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_EQ(account_id, device_account_id_);
 
   if (refresh_token_is_valid_) {
-    return OAuth2TokenService::StartRequest(scopes, consumer).Pass();
+    return OAuth2TokenService::StartRequest(
+        account_id, scopes, consumer).Pass();
   } else {
     scoped_ptr<ValidatingConsumer> validating_consumer(
         new ValidatingConsumer(this, consumer));
 
     scoped_ptr<Request> request = OAuth2TokenService::StartRequest(
-        scopes, validating_consumer.get());
+        account_id, scopes, validating_consumer.get());
     validating_consumer->StartValidation(request.Pass());
     return validating_consumer.PassAs<Request>();
   }
 }
 
 void DeviceOAuth2TokenService::OnValidationComplete(
     bool refresh_token_is_valid) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   refresh_token_is_valid_ = refresh_token_is_valid;
 }
 
 // static
 void DeviceOAuth2TokenService::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kDeviceRobotAnyApiRefreshToken,
                                std::string());
 }
 
 void DeviceOAuth2TokenService::SetAndSaveRefreshToken(
     const std::string& refresh_token) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   std::string encrypted_refresh_token =
       CryptohomeLibrary::Get()->EncryptWithSystemSalt(refresh_token);
 
   local_state_->SetString(prefs::kDeviceRobotAnyApiRefreshToken,
                           encrypted_refresh_token);
 }
 
-std::string DeviceOAuth2TokenService::GetRefreshToken() {
+std::string DeviceOAuth2TokenService::GetRefreshToken(
+    const std::string& account_id) {
+  DCHECK_EQ(account_id, device_account_id_);
   if (refresh_token_.empty()) {
     std::string encrypted_refresh_token =
         local_state_->GetString(prefs::kDeviceRobotAnyApiRefreshToken);
 
     refresh_token_ = CryptohomeLibrary::Get()->DecryptWithSystemSalt(
         encrypted_refresh_token);
   }
   return refresh_token_;
 }
 
+const std::string& DeviceOAuth2TokenService::GetDeviceAccountId() const {
+  return device_account_id_;
+}
+
 std::string DeviceOAuth2TokenService::GetRobotAccountId() {
   policy::BrowserPolicyConnector* connector =
       g_browser_process->browser_policy_connector();
   if (connector)
     return connector->GetDeviceCloudPolicyManager()->GetRobotAccountId();
   return std::string();
 }
 
 net::URLRequestContextGetter* DeviceOAuth2TokenService::GetRequestContext() {
   return url_request_context_getter_.get();
 }
 
 }  // namespace chromeos