Get OAuth2TokenService working on Android.

chrome/browser/sync/profile_sync_service_android.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/sync/profile_sync_service_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/signin/oauth2_token_service.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/signin/token_service_factory.h"
 #include "chrome/browser/sync/about_sync_util.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/sync_prefs.h"
 #include "chrome/browser/sync/sync_ui_util.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 134 matching lines @@
       env, weak_java_profile_sync_service_.get(env).obj());
 }
 
 void ProfileSyncServiceAndroid::TokenAvailable(
     JNIEnv* env, jobject, jstring username, jstring auth_token) {
   std::string token = ConvertJavaStringToUTF8(env, auth_token);
   TokenServiceFactory::GetForProfile(profile_)->OnIssueAuthTokenSuccess(
       GaiaConstants::kSyncService, token);
 }
 
+void ProfileSyncServiceAndroid::InvalidateOAuth2Token(
+    const std::string& scope, const std::string& invalid_token) {
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jstring> j_scope =
+      ConvertUTF8ToJavaString(env, scope);
+  ScopedJavaLocalRef<jstring> j_invalid_token =
+      ConvertUTF8ToJavaString(env, invalid_token);
+  Java_ProfileSyncService_invalidateOAuth2AuthToken(
+      env, weak_java_profile_sync_service_.get(env).obj(),
+      j_scope.obj(),
+      j_invalid_token.obj());
+}
+
+void ProfileSyncServiceAndroid::FetchOAuth2Token(
+    const std::string& scope, const FetchOAuth2TokenCallback& callback) {
+  const std::string& sync_username =
+      SigninManagerFactory::GetForProfile(profile_)->GetAuthenticatedUsername();
+
+  // Call into java to invalidate the current token and get a new one.

[Roger Tawa OOO till Jul 10th, 2013/03/25 20:47:20]

is this comment correct?

[Patrick Dubroy, 2013/03/25 21:15:49]

Nope, done.

+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jstring> j_sync_username =
+      ConvertUTF8ToJavaString(env, sync_username);
+  ScopedJavaLocalRef<jstring> j_scope =
+      ConvertUTF8ToJavaString(env, scope);
+
+  // Allocate a copy of the callback on the heap, because the callback
+  // 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));
+
+  Java_ProfileSyncService_getOAuth2AuthToken(
+      env, weak_java_profile_sync_service_.get(env).obj(),
+      j_sync_username.obj(),
+      j_scope.obj(),
+      reinterpret_cast<int>(heap_callback.release()));
+}
+
+void ProfileSyncServiceAndroid::OAuth2TokenFetched(
+    JNIEnv* env, jobject, int callback, jstring auth_token, jboolean result) {
+  std::string token = ConvertJavaStringToUTF8(env, auth_token);
+  scoped_ptr<FetchOAuth2TokenCallback> heap_callback(
+      reinterpret_cast<FetchOAuth2TokenCallback*>(callback));
+  GoogleServiceAuthError err(result ?
+                             GoogleServiceAuthError::NONE :
+                             GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
+  heap_callback->Run(err, token, base::Time());
+}
+
 void ProfileSyncServiceAndroid::EnableSync(JNIEnv* env, jobject) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Don't need to do anything if we're already enabled.
   browser_sync::SyncPrefs prefs(profile_->GetPrefs());
   if (prefs.IsStartSuppressed())
     sync_service_->UnsuppressAndStart();
   else
     DVLOG(2) << "Ignoring call to EnableSync() because sync is already enabled";
 }
 
@@ skipping 345 matching lines @@
 void ProfileSyncServiceAndroid::NudgeSyncer(JNIEnv* env,
                                             jobject obj,
                                             jstring objectId,
                                             jlong version,
                                             jstring state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   SendNudgeNotification(ConvertJavaStringToUTF8(env, objectId), version,
                         ConvertJavaStringToUTF8(env, state));
 }
 
+// static
+ProfileSyncServiceAndroid*
+    ProfileSyncServiceAndroid::GetProfileSyncServiceAndroid() {
+  return reinterpret_cast<ProfileSyncServiceAndroid*>(
+          Java_ProfileSyncService_getProfileSyncServiceAndroid(
+      AttachCurrentThread(), base::android::GetApplicationContext()));
+}
+
 static int Init(JNIEnv* env, jobject obj) {
   ProfileSyncServiceAndroid* profile_sync_service_android =
       new ProfileSyncServiceAndroid(env, obj);
   profile_sync_service_android->Init();
   return reinterpret_cast<jint>(profile_sync_service_android);
 }
 
 // static
 bool ProfileSyncServiceAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }