Convert UserPolicySigninService to use OAuth2TokenService

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"
@@ skipping 18 matching lines @@
   std::string scope;
   for (OAuth2TokenService::ScopeSet::const_iterator it = scopes.begin();
        it != scopes.end(); ++it) {
     if (!scope.empty())
       scope += " ";
     scope += *it;
   }
   return scope;
 }
 
+// Callback from FetchOAuth2TokenWithUsername().
+// Arguments:
+// - the error, or NONE if the token fetch was successful.
+// - the OAuth2 access token.
+// - the expiry time of the token (may be null, indicating that the expiry
+//   time is unknown.
+typedef base::Callback<void(
+    const GoogleServiceAuthError&, const std::string&, const base::Time&)>

[awong, 2013/08/16 17:53:16]

nit: passing base::Time by value is oft preferred to by reference since it's
effectively a primitive int.

[Andrew T Wilson (Slow), 2013/08/19 12:15:56]

This callback basically matches
OAuth2TokenService::RequestImpl::InformConsumer(), so I'm not going to change
the API in this CL.

At some point we'll change RequestImpl to generate its own Callback and not
expose InformConsumer() and we can tweak the code then.

+        FetchOAuth2TokenCallback;
+
 }  // namespace
 
 AndroidProfileOAuth2TokenService::AndroidProfileOAuth2TokenService() {
 }
 
 AndroidProfileOAuth2TokenService::~AndroidProfileOAuth2TokenService() {
 }
 
 scoped_ptr<OAuth2TokenService::Request>
-    AndroidProfileOAuth2TokenService::StartRequest(
-        const OAuth2TokenService::ScopeSet& scopes,
-        OAuth2TokenService::Consumer* consumer) {
-  const std::string& sync_username =
-      SigninManagerFactory::GetForProfile(profile())->
-          GetAuthenticatedUsername();
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  DCHECK(!sync_username.empty());
-  return StartRequestForUsername(sync_username, scopes, consumer);
-}
-
-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));
-  FetchOAuth2Token(
-      username,
-      CombineScopes(scopes),
-      base::Bind(&RequestImpl::InformConsumer, request->AsWeakPtr()));
+  FetchOAuth2TokenWithUsername(request.get(),
+                               username,
+                               scopes);
   return request.PassAs<Request>();
 }
 
 bool AndroidProfileOAuth2TokenService::RefreshTokenIsAvailable() {
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile());
   return !signin_manager->GetAuthenticatedUsername().empty();
 }
 
 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,
+    net::URLRequestContextGetter* getter,
+    const std::string& client_id,
+    const std::string& client_secret,
+    const OAuth2TokenService::ScopeSet& scopes) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  const std::string& username =

[awong, 2013/08/16 17:53:16]

nit: you rely on RVO on line 110 but use a const & here...make consistent?

[Andrew T Wilson (Slow), 2013/08/19 12:15:56]

Done.

+      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);
+}
+
+void AndroidProfileOAuth2TokenService::FetchOAuth2TokenWithUsername(
+    RequestImpl* request,
     const std::string& username,
-    const std::string& scope,
-    const FetchOAuth2TokenCallback& callback) {
+    const OAuth2TokenService::ScopeSet& scopes) {
   JNIEnv* env = AttachCurrentThread();
+  std::string scope = CombineScopes(scopes);
   ScopedJavaLocalRef<jstring> j_username =
       ConvertUTF8ToJavaString(env, username);
   ScopedJavaLocalRef<jstring> j_scope =
       ConvertUTF8ToJavaString(env, scope);
 
-  // Allocate a copy of the callback on the heap, because the callback
+  // 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(callback));
+      new FetchOAuth2TokenCallback(base::Bind(&RequestImpl::InformConsumer,
+                                              request->AsWeakPtr())));
 
   // Call into Java to get a new token.
   Java_AndroidProfileOAuth2TokenServiceHelper_getOAuth2AuthToken(
       env, base::android::GetApplicationContext(),
       j_username.obj(),
       j_scope.obj(),
       reinterpret_cast<int>(heap_callback.release()));
 }
 
 // Called from Java when fetching of an OAuth2 token is finished. The
 // |authToken| param is only valid when |result| is true.
 void OAuth2TokenFetched(JNIEnv* env, jclass clazz,
     jstring authToken,
     jboolean result,
     jint nativeCallback) {
   std::string token = ConvertJavaStringToUTF8(env, authToken);
-  scoped_ptr<AndroidProfileOAuth2TokenService::FetchOAuth2TokenCallback>
-      heap_callback(
-          reinterpret_cast<
-              AndroidProfileOAuth2TokenService::FetchOAuth2TokenCallback*>(
-                  nativeCallback));
+  scoped_ptr<FetchOAuth2TokenCallback> heap_callback(
+      reinterpret_cast<FetchOAuth2TokenCallback*>(nativeCallback));
   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);
 }