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

chrome/browser/policy/cloud/cloud_policy_client_registration_helper.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/policy/cloud/cloud_policy_client_registration_helper.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 
-#if defined(OS_ANDROID)
-#include "chrome/browser/signin/android_profile_oauth2_token_service.h"
-#else
+#if !defined(OS_ANDROID)
 #include "google_apis/gaia/oauth2_access_token_consumer.h"
 #include "google_apis/gaia/oauth2_access_token_fetcher.h"
 #endif
 
 namespace policy {
 
 // OAuth2 scope for the userinfo service.
 const char kServiceScopeGetUserInfo[] =
     "https://www.googleapis.com/auth/userinfo.email";
 
 // The key under which the hosted-domain value is stored in the UserInfo
 // response.
 const char kGetHostedDomainKey[] = "hd";
 
 typedef base::Callback<void(const std::string&)> StringCallback;
 
 // This class fetches an OAuth2 token scoped for the userinfo and DM services.
 // On Android, we use a special API to allow us to fetch a token for an account
 // that is not yet logged in to allow fetching the token before the sign-in
 // process is finished.
 class CloudPolicyClientRegistrationHelper::TokenServiceHelper
     : public OAuth2TokenService::Consumer {
  public:
   TokenServiceHelper();
 
   void FetchAccessToken(
-#if defined(OS_ANDROID)
-      // TODO(atwilson): Remove this when StartRequestForUsername() is merged
-      // into the base OAuth2TokenService class.
-      AndroidProfileOAuth2TokenService* token_service,
-#else
       OAuth2TokenService* token_service,
-#endif
       const std::string& username,
       const StringCallback& callback);
 
  private:
   // OAuth2TokenService::Consumer implementation:
   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;
 
   StringCallback callback_;
   scoped_ptr<OAuth2TokenService::Request> token_request_;
 };
 
 CloudPolicyClientRegistrationHelper::TokenServiceHelper::TokenServiceHelper() {}
 
 void CloudPolicyClientRegistrationHelper::TokenServiceHelper::FetchAccessToken(
-#if defined(OS_ANDROID)
-    AndroidProfileOAuth2TokenService* token_service,
-#else
     OAuth2TokenService* token_service,
-#endif
-    const std::string& username,
+    const std::string& account_id,
     const StringCallback& callback) {
   DCHECK(!token_request_);
   // Either the caller must supply a username, or the user must be signed in
   // already.
-  DCHECK(!username.empty() || token_service->RefreshTokenIsAvailable());
+  DCHECK(!account_id.empty());
+  DCHECK(token_service->RefreshTokenIsAvailable(account_id));
+
   callback_ = callback;
 
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(GaiaConstants::kDeviceManagementServiceOAuth);
   scopes.insert(kServiceScopeGetUserInfo);
-
-#if defined(OS_ANDROID)
-  token_request_ =
-      token_service->StartRequestForUsername(username, scopes, this);
-#else
-  token_request_ = token_service->StartRequest(scopes, this);
-#endif
+  token_request_ = token_service->StartRequest(account_id, scopes, this);
 }
 
 void CloudPolicyClientRegistrationHelper::TokenServiceHelper::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK_EQ(token_request_.get(), request);
   callback_.Run(access_token);
 }
 
@@ skipping 82 matching lines @@
 
 CloudPolicyClientRegistrationHelper::~CloudPolicyClientRegistrationHelper() {
   // Clean up any pending observers in case the browser is shutdown while
   // trying to register for policy.
   if (client_)
     client_->RemoveObserver(this);
 }
 
 
 void CloudPolicyClientRegistrationHelper::StartRegistration(
-#if defined(OS_ANDROID)
-    AndroidProfileOAuth2TokenService* token_service,
-#else
     OAuth2TokenService* token_service,
-#endif
-    const std::string& username,
+    const std::string& account_id,
     const base::Closure& callback) {
   DVLOG(1) << "Starting registration process with username";
   DCHECK(!client_->is_registered());
   callback_ = callback;
   client_->AddObserver(this);
 
   token_service_helper_.reset(new TokenServiceHelper());
   token_service_helper_->FetchAccessToken(
       token_service,
-      username,
+      account_id,
       base::Bind(&CloudPolicyClientRegistrationHelper::OnTokenFetched,
                  base::Unretained(this)));
 }
 
 #if !defined(OS_ANDROID)
 void CloudPolicyClientRegistrationHelper::StartRegistrationWithLoginToken(
     const std::string& login_refresh_token,
     const base::Closure& callback) {
   DVLOG(1) << "Starting registration process with login token";
   DCHECK(!client_->is_registered());
@@ skipping 87 matching lines @@
 void CloudPolicyClientRegistrationHelper::RequestCompleted() {
   if (client_) {
     client_->RemoveObserver(this);
     // |client_| may be freed by the callback so clear it now.
     client_ = NULL;
     callback_.Run();
   }
 }
 
 }  // namespace policy