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

chrome/browser/signin/android_profile_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/signin/android_profile_oauth2_token_service.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service_android.h"
 #include "content/public/browser/browser_thread.h"
 #include "jni/AndroidProfileOAuth2TokenServiceHelper_jni.h"
 
 using base::android::AttachCurrentThread;
-using base::android::CheckException;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaLocalRef;
 using content::BrowserThread;
 
 namespace {
 
 std::string CombineScopes(const OAuth2TokenService::ScopeSet& scopes) {
   // The Android AccountManager supports multiple scopes separated by a space:
   // https://code.google.com/p/google-api-java-client/wiki/OAuth2#Android
@@ skipping 18 matching lines @@
         FetchOAuth2TokenCallback;
 
 }  // namespace
 
 AndroidProfileOAuth2TokenService::AndroidProfileOAuth2TokenService() {
 }
 
 AndroidProfileOAuth2TokenService::~AndroidProfileOAuth2TokenService() {
 }
 
-scoped_ptr<OAuth2TokenService::Request>
-    AndroidProfileOAuth2TokenService::StartRequestForUsername(
-        const std::string& username,
-        const OAuth2TokenService::ScopeSet& scopes,
-        OAuth2TokenService::Consumer* consumer) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
-  scoped_ptr<RequestImpl> request(new RequestImpl(consumer));
-  FetchOAuth2TokenWithUsername(request.get(), username, scopes);
-  return request.PassAs<Request>();
-}
-
-bool AndroidProfileOAuth2TokenService::RefreshTokenIsAvailable() {
+bool AndroidProfileOAuth2TokenService::RefreshTokenIsAvailable(
+    const std::string& account_id) {
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile());
-  return !signin_manager->GetAuthenticatedUsername().empty();
+  const std::string& authenticated_username =
+      signin_manager->GetAuthenticatedUsername();
+  return !authenticated_username.empty()
+      && authenticated_username == account_id;

[Roger Tawa OOO till Jul 10th, 2013/08/29 15:41:40]

Shouldn't this check the underlying android account manager to see if an account
is available?  Even the old code before your change seems incorrect.  I'll ask
Tommy to take a look.

[fgorski, 2013/08/29 23:04:14]

You are correct, however there are 2 ways to go about that:
1. If we want all of the accounts in Android to be visible here, we check with
system account manager.
2. Otherwise we filter it down only to the accounts that we want to expose in
Chrome, and the logic had to be a bit more sophisticated.

I didn't want to solve the issue here (due to size of CL), hence went with a
simple check for a primary account. 

[Roger Tawa OOO till Jul 10th, 2013/08/30 00:40:08]

The goal is to expose all the android accounts here, yes.

 }
 
 void AndroidProfileOAuth2TokenService::InvalidateToken(
     const ScopeSet& scopes,
     const std::string& invalid_token) {
   OAuth2TokenService::InvalidateToken(scopes, invalid_token);
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_invalid_token =
       ConvertUTF8ToJavaString(env, invalid_token);
   Java_AndroidProfileOAuth2TokenServiceHelper_invalidateOAuth2AuthToken(
       env, base::android::GetApplicationContext(),
       j_invalid_token.obj());
 }
 
 void AndroidProfileOAuth2TokenService::FetchOAuth2Token(
     RequestImpl* request,
+    const std::string& account_id,
     net::URLRequestContextGetter* getter,
     const std::string& client_id,
     const std::string& client_secret,
     const OAuth2TokenService::ScopeSet& scopes) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  std::string username = SigninManagerFactory::GetForProfile(profile())->
-      GetAuthenticatedUsername();
-  DCHECK(!username.empty());
-  // Just ignore client_id, getter, etc since we don't use them on Android.
-  FetchOAuth2TokenWithUsername(request, username, scopes);
-}
+  DCHECK(!account_id.empty());
 
-void AndroidProfileOAuth2TokenService::FetchOAuth2TokenWithUsername(
-    RequestImpl* request,
-    const std::string& username,
-    const OAuth2TokenService::ScopeSet& scopes) {
   JNIEnv* env = AttachCurrentThread();
   std::string scope = CombineScopes(scopes);
   ScopedJavaLocalRef<jstring> j_username =
-      ConvertUTF8ToJavaString(env, username);
+      ConvertUTF8ToJavaString(env, account_id);
   ScopedJavaLocalRef<jstring> j_scope =
       ConvertUTF8ToJavaString(env, scope);
 
   // Allocate a copy of the request WeakPtr on the heap, because the object
   // needs to be passed through JNI as an int.
   // It will be passed back to OAuth2TokenFetched(), where it will be freed.
   scoped_ptr<FetchOAuth2TokenCallback> heap_callback(
       new FetchOAuth2TokenCallback(base::Bind(&RequestImpl::InformConsumer,
                                               request->AsWeakPtr())));
 
@@ skipping 17 matching lines @@
   GoogleServiceAuthError err(result ?
                              GoogleServiceAuthError::NONE :
                              GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
   heap_callback->Run(err, token, base::Time());
 }
 
 // static
 bool AndroidProfileOAuth2TokenService::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }