Remove now-unnecessary .obj() in Java method calls.

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"
@@ skipping 77 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, base::android::GetApplicationContext(), j_username.obj(),
-      j_scope.obj(), reinterpret_cast<intptr_t>(heap_callback.release()));
+      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,
     const base::Time& expiration_time) {
@@ skipping 53 matching lines @@
     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, base::android::GetApplicationContext(), java_accounts.obj());
+        env, base::android::GetApplicationContext(), java_accounts);
   }
 
   if (!is_testing_profile_) {
     Java_OAuth2TokenService_validateAccounts(
-        AttachCurrentThread(), java_ref_.obj(),
+        AttachCurrentThread(), java_ref_,
         base::android::GetApplicationContext(), JNI_TRUE);
   }
 }
 
 OAuth2TokenServiceDelegateAndroid::~OAuth2TokenServiceDelegateAndroid() {
 }
 
 // static
 ScopedJavaLocalRef<jobject> OAuth2TokenServiceDelegateAndroid::GetForProfile(
     JNIEnv* env,
@@ skipping 18 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, base::android::GetApplicationContext(), j_account_id.obj());
+          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);
 }
 
@@ skipping 50 matching lines @@
 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, base::android::GetApplicationContext(), j_access_token.obj());
+      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 41 matching lines @@
   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, base::android::GetApplicationContext(), java_accounts.obj());
+      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 81 matching lines @@
 void OAuth2TokenServiceDelegateAndroid::FireRefreshTokenAvailable(
     const std::string& account_id) {
   DCHECK(!account_id.empty());
   DVLOG(1) << "OAuth2TokenServiceDelegateAndroid::FireRefreshTokenAvailable id="
            << account_id;
   std::string account_name = MapAccountIdToAccountName(account_id);
   DCHECK(!account_name.empty());
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_account_name =
       ConvertUTF8ToJavaString(env, account_name);
-  Java_OAuth2TokenService_notifyRefreshTokenAvailable(env, java_ref_.obj(),
-                                                      j_account_name.obj());
+  Java_OAuth2TokenService_notifyRefreshTokenAvailable(env, java_ref_,
+                                                      j_account_name);
   OAuth2TokenServiceDelegate::FireRefreshTokenAvailable(account_id);
 }
 
 void OAuth2TokenServiceDelegateAndroid::FireRefreshTokenRevokedFromJava(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jstring>& account_name) {
   std::string account_id =
       MapAccountNameToAccountId(ConvertJavaStringToUTF8(env, account_name));
   // Notify native observers.
   FireRefreshTokenRevoked(account_id);
 }
 
 void OAuth2TokenServiceDelegateAndroid::FireRefreshTokenRevoked(
     const std::string& account_id) {
   DCHECK(!account_id.empty());
   DVLOG(1) << "OAuth2TokenServiceDelegateAndroid::FireRefreshTokenRevoked id="
            << account_id;
   std::string account_name = MapAccountIdToAccountName(account_id);
   if (!account_name.empty()) {
     JNIEnv* env = AttachCurrentThread();
     ScopedJavaLocalRef<jstring> j_account_name =
         ConvertUTF8ToJavaString(env, account_name);
-    Java_OAuth2TokenService_notifyRefreshTokenRevoked(env, java_ref_.obj(),
-                                                      j_account_name.obj());
+    Java_OAuth2TokenService_notifyRefreshTokenRevoked(env, java_ref_,
+                                                      j_account_name);
   } else {
     // Current prognosis is that we have an unmigrated account which is due for
     // deletion. Record a histogram to debug this.
     UMA_HISTOGRAM_ENUMERATION("OAuth2Login.AccountRevoked.MigrationState",
                               account_tracker_service_->GetMigrationState(),
                               AccountTrackerService::NUM_MIGRATION_STATES);
     bool is_email_id = account_id.find('@') != std::string::npos;
     UMA_HISTOGRAM_BOOLEAN("OAuth2Login.AccountRevoked.IsEmailId", is_email_id);
   }
   OAuth2TokenServiceDelegate::FireRefreshTokenRevoked(account_id);
 }
 
 void OAuth2TokenServiceDelegateAndroid::FireRefreshTokensLoadedFromJava(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj) {
   // Notify native observers.
   FireRefreshTokensLoaded();
 }
 
 void OAuth2TokenServiceDelegateAndroid::FireRefreshTokensLoaded() {
   DVLOG(1) << "OAuth2TokenServiceDelegateAndroid::FireRefreshTokensLoaded";
   JNIEnv* env = AttachCurrentThread();
-  Java_OAuth2TokenService_notifyRefreshTokensLoaded(env, java_ref_.obj());
+  Java_OAuth2TokenService_notifyRefreshTokensLoaded(env, java_ref_);
   OAuth2TokenServiceDelegate::FireRefreshTokensLoaded();
 }
 
 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, base::android::GetApplicationContext(), java_accounts.obj());
+      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);
 }