Revert of Android: Remove GetApplicationContext part 2

chrome/browser/signin/oauth2_token_service_delegate_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/signin/oauth2_token_service_delegate_android.h"
 
+#include "base/android/context_utils.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "chrome/browser/profiles/profile_android.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
@@ skipping 70 matching lines @@
   ScopedJavaLocalRef<jstring> j_username =
       ConvertUTF8ToJavaString(env, account_id_);
   ScopedJavaLocalRef<jstring> j_scope = ConvertUTF8ToJavaString(env, scope);
   std::unique_ptr<FetchOAuth2TokenCallback> heap_callback(
       new FetchOAuth2TokenCallback(
           base::Bind(&AndroidAccessTokenFetcher::OnAccessTokenResponse,
                      weak_factory_.GetWeakPtr())));
 
   // Call into Java to get a new token.
   Java_OAuth2TokenService_getOAuth2AuthToken(
-      env, j_username, j_scope,
+      env, base::android::GetApplicationContext(), j_username, j_scope,
       reinterpret_cast<intptr_t>(heap_callback.release()));
 }
 
 void AndroidAccessTokenFetcher::CancelRequest() {
   request_was_cancelled_ = true;
 }
 
 void AndroidAccessTokenFetcher::OnAccessTokenResponse(
     const GoogleServiceAuthError& error,
     const std::string& access_token,
@@ skipping 36 matching lines @@
     : error(error) {}
 
 OAuth2TokenServiceDelegateAndroid::OAuth2TokenServiceDelegateAndroid(
     AccountTrackerService* account_tracker_service)
     : account_tracker_service_(account_tracker_service),
       fire_refresh_token_loaded_(RT_LOAD_NOT_START) {
   DVLOG(1) << "OAuth2TokenServiceDelegateAndroid::ctor";
   DCHECK(account_tracker_service_);
   JNIEnv* env = AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jobject> local_java_ref =
-      Java_OAuth2TokenService_create(env, reinterpret_cast<intptr_t>(this));
+      Java_OAuth2TokenService_create(env,
+                                     base::android::GetApplicationContext(),
+                                     reinterpret_cast<intptr_t>(this));
   java_ref_.Reset(env, local_java_ref.obj());
 
   if (account_tracker_service_->GetMigrationState() ==
       AccountTrackerService::MIGRATION_IN_PROGRESS) {
     std::vector<std::string> accounts = GetAccounts();
     std::vector<std::string> accounts_id;
     for (auto account_name : accounts) {
       AccountInfo account_info =
           account_tracker_service_->FindAccountInfoByEmail(account_name);
       DCHECK(!account_info.gaia.empty());
       accounts_id.push_back(account_info.gaia);
     }
     ScopedJavaLocalRef<jobjectArray> java_accounts(
         base::android::ToJavaArrayOfStrings(env, accounts_id));
-    Java_OAuth2TokenService_saveStoredAccounts(env, java_accounts);
+    Java_OAuth2TokenService_saveStoredAccounts(
+        env, base::android::GetApplicationContext(), java_accounts);
   }
 
   if (!is_testing_profile_) {
-    Java_OAuth2TokenService_validateAccounts(AttachCurrentThread(), java_ref_,
-                                             JNI_TRUE);
+    Java_OAuth2TokenService_validateAccounts(
+        AttachCurrentThread(), java_ref_,
+        base::android::GetApplicationContext(), JNI_TRUE);
   }
 }
 
 OAuth2TokenServiceDelegateAndroid::~OAuth2TokenServiceDelegateAndroid() {
 }
 
 // static
 ScopedJavaLocalRef<jobject> OAuth2TokenServiceDelegateAndroid::GetForProfile(
     JNIEnv* env,
     jclass clazz,
@@ skipping 16 matching lines @@
 
 bool OAuth2TokenServiceDelegateAndroid::RefreshTokenIsAvailable(
     const std::string& account_id) const {
   DVLOG(1) << "OAuth2TokenServiceDelegateAndroid::RefreshTokenIsAvailable"
            << " account= " << account_id;
   std::string account_name = MapAccountIdToAccountName(account_id);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_account_id =
       ConvertUTF8ToJavaString(env, account_name);
   jboolean refresh_token_is_available =
-      Java_OAuth2TokenService_hasOAuth2RefreshToken(env, j_account_id);
+      Java_OAuth2TokenService_hasOAuth2RefreshToken(
+          env, base::android::GetApplicationContext(), j_account_id);
   return refresh_token_is_available == JNI_TRUE;
 }
 
 bool OAuth2TokenServiceDelegateAndroid::RefreshTokenHasError(
     const std::string& account_id) const {
   auto it = errors_.find(account_id);
   // TODO(rogerta): should we distinguish between transient and persistent?
   return it == errors_.end() ? false : IsError(it->second.error);
 }
 
 void OAuth2TokenServiceDelegateAndroid::UpdateAuthError(
     const std::string& account_id,
     const GoogleServiceAuthError& error) {
   DVLOG(1) << "OAuth2TokenServiceDelegateAndroid::UpdateAuthError"
            << " account=" << account_id
            << " error=" << error.ToString();
   if (error.state() == GoogleServiceAuthError::NONE) {
     errors_.erase(account_id);
   } else {
     // TODO(rogerta): should we distinguish between transient and persistent?
     errors_[account_id] = ErrorInfo(error);
   }
 }
 
 std::vector<std::string> OAuth2TokenServiceDelegateAndroid::GetAccounts() {
   std::vector<std::string> accounts;
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobjectArray> j_accounts =
-      Java_OAuth2TokenService_getAccounts(env);
+      Java_OAuth2TokenService_getAccounts(
+          env, base::android::GetApplicationContext());
   // TODO(fgorski): We may decide to filter out some of the accounts.
   base::android::AppendJavaStringArrayToStringVector(env, j_accounts.obj(),
                                                      &accounts);
   return accounts;
 }
 
 std::vector<std::string>
 OAuth2TokenServiceDelegateAndroid::GetSystemAccountNames() {
   std::vector<std::string> account_names;
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobjectArray> j_accounts =
-      Java_OAuth2TokenService_getSystemAccountNames(env);
+      Java_OAuth2TokenService_getSystemAccountNames(
+          env, base::android::GetApplicationContext());
   base::android::AppendJavaStringArrayToStringVector(env, j_accounts.obj(),
                                                      &account_names);
   return account_names;
 }
 
 OAuth2AccessTokenFetcher*
 OAuth2TokenServiceDelegateAndroid::CreateAccessTokenFetcher(
     const std::string& account_id,
     net::URLRequestContextGetter* getter,
     OAuth2AccessTokenConsumer* consumer) {
   DVLOG(1) << "OAuth2TokenServiceDelegateAndroid::CreateAccessTokenFetcher"
            << " account= " << account_id;
   ValidateAccountId(account_id);
   return new AndroidAccessTokenFetcher(consumer,
                                        MapAccountIdToAccountName(account_id));
 }
 
 void OAuth2TokenServiceDelegateAndroid::InvalidateAccessToken(
     const std::string& account_id,
     const std::string& client_id,
     const OAuth2TokenService::ScopeSet& scopes,
     const std::string& access_token) {
   ValidateAccountId(account_id);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_access_token =
       ConvertUTF8ToJavaString(env, access_token);
-  Java_OAuth2TokenService_invalidateOAuth2AuthToken(env, j_access_token);
+  Java_OAuth2TokenService_invalidateOAuth2AuthToken(
+      env, base::android::GetApplicationContext(), j_access_token);
 }
 
 void OAuth2TokenServiceDelegateAndroid::ValidateAccounts(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jstring>& j_current_acc,
     jboolean j_force_notifications) {
   std::string signed_in_account_name;
   DVLOG(1) << "OAuth2TokenServiceDelegateAndroid::ValidateAccounts from java";
   if (j_current_acc)
@@ skipping 40 matching lines @@
   ScopedJavaLocalRef<jobjectArray> java_accounts;
   if (currently_signed_in) {
     java_accounts = base::android::ToJavaArrayOfStrings(env, curr_ids);
   } else {
     java_accounts =
         base::android::ToJavaArrayOfStrings(env, std::vector<std::string>());
   }
 
   // Save the current accounts in the token service before calling
   // FireRefreshToken* methods.
-  Java_OAuth2TokenService_saveStoredAccounts(env, java_accounts);
+  Java_OAuth2TokenService_saveStoredAccounts(
+      env, base::android::GetApplicationContext(), java_accounts);
 
   for (const std::string& refreshed_id : refreshed_ids)
     FireRefreshTokenAvailable(refreshed_id);
   for (const std::string& revoked_id : revoked_ids)
     FireRefreshTokenRevoked(revoked_id);
   if (fire_refresh_token_loaded_ == RT_WAIT_FOR_VALIDATION) {
     fire_refresh_token_loaded_ = RT_LOADED;
     FireRefreshTokensLoaded();
   } else if (fire_refresh_token_loaded_ == RT_LOAD_NOT_START) {
     fire_refresh_token_loaded_ = RT_HAS_BEEN_VALIDATED;
@@ skipping 144 matching lines @@
 void OAuth2TokenServiceDelegateAndroid::RevokeAllCredentials() {
   DVLOG(1) << "OAuth2TokenServiceDelegateAndroid::RevokeAllCredentials";
   ScopedBatchChange batch(this);
   std::vector<std::string> accounts_to_revoke = GetAccounts();
 
   // Clear accounts in the token service before calling
   // |FireRefreshTokenRevoked|.
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobjectArray> java_accounts(
       base::android::ToJavaArrayOfStrings(env, std::vector<std::string>()));
-  Java_OAuth2TokenService_saveStoredAccounts(env, java_accounts);
+  Java_OAuth2TokenService_saveStoredAccounts(
+      env, base::android::GetApplicationContext(), java_accounts);
 
   for (const std::string& account : accounts_to_revoke)
     FireRefreshTokenRevoked(account);
 }
 
 void OAuth2TokenServiceDelegateAndroid::LoadCredentials(
     const std::string& primary_account_id) {
   if (primary_account_id.empty()) {
     FireRefreshTokensLoaded();
     return;
@@ skipping 40 matching lines @@
               : isTransientError
                     ? GoogleServiceAuthError::CONNECTION_FAILED
                     : GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
   heap_callback->Run(err, token, base::Time());
 }
 
 // static
 bool OAuth2TokenServiceDelegateAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }