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

components/gcm_driver/instance_id/instance_id_android.cc

 // Copyright 2015 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 "components/gcm_driver/instance_id/instance_id_android.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 44 matching lines @@
     : InstanceID(app_id, gcm_driver) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DCHECK(!app_id.empty()) << "Empty app_id is not supported";
   // The |app_id| is stored in GCM's category field by the desktop InstanceID
   // implementation, but because the category is reserved for the app's package
   // name on Android the subtype field is used instead.
   std::string subtype = app_id;
 
   JNIEnv* env = AttachCurrentThread();
-  java_ref_.Reset(Java_InstanceIDBridge_create(
-      env, reinterpret_cast<intptr_t>(this),
-      base::android::GetApplicationContext(),
-      ConvertUTF8ToJavaString(env, subtype).obj()));
+  java_ref_.Reset(
+      Java_InstanceIDBridge_create(env, reinterpret_cast<intptr_t>(this),
+                                   base::android::GetApplicationContext(),
+                                   ConvertUTF8ToJavaString(env, subtype)));
 }
 
 InstanceIDAndroid::~InstanceIDAndroid() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   JNIEnv* env = AttachCurrentThread();
-  Java_InstanceIDBridge_destroy(env, java_ref_.obj());
+  Java_InstanceIDBridge_destroy(env, java_ref_);
 }
 
 void InstanceIDAndroid::GetID(const GetIDCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   int32_t request_id = get_id_callbacks_.Add(new GetIDCallback(callback));
 
   JNIEnv* env = AttachCurrentThread();
-  Java_InstanceIDBridge_getId(env, java_ref_.obj(), request_id);
+  Java_InstanceIDBridge_getId(env, java_ref_, request_id);
 }
 
 void InstanceIDAndroid::GetCreationTime(
     const GetCreationTimeCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   int32_t request_id =
       get_creation_time_callbacks_.Add(new GetCreationTimeCallback(callback));
 
   JNIEnv* env = AttachCurrentThread();
-  Java_InstanceIDBridge_getCreationTime(env, java_ref_.obj(), request_id);
+  Java_InstanceIDBridge_getCreationTime(env, java_ref_, request_id);
 }
 
 void InstanceIDAndroid::GetToken(
     const std::string& authorized_entity,
     const std::string& scope,
     const std::map<std::string, std::string>& options,
     const GetTokenCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   int32_t request_id = get_token_callbacks_.Add(new GetTokenCallback(callback));
 
   std::vector<std::string> options_strings;
   for (const auto& entry : options) {
     options_strings.push_back(entry.first);
     options_strings.push_back(entry.second);
   }
 
   JNIEnv* env = AttachCurrentThread();
   Java_InstanceIDBridge_getToken(
-      env, java_ref_.obj(), request_id,
-      ConvertUTF8ToJavaString(env, authorized_entity).obj(),
-      ConvertUTF8ToJavaString(env, scope).obj(),
-      base::android::ToJavaArrayOfStrings(env, options_strings).obj());
+      env, java_ref_, request_id,
+      ConvertUTF8ToJavaString(env, authorized_entity),
+      ConvertUTF8ToJavaString(env, scope),
+      base::android::ToJavaArrayOfStrings(env, options_strings));
 }
 
 void InstanceIDAndroid::DeleteTokenImpl(const std::string& authorized_entity,
                                         const std::string& scope,
                                         const DeleteTokenCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   int32_t request_id =
       delete_token_callbacks_.Add(new DeleteTokenCallback(callback));
 
   JNIEnv* env = AttachCurrentThread();
   Java_InstanceIDBridge_deleteToken(
-      env, java_ref_.obj(), request_id,
-      ConvertUTF8ToJavaString(env, authorized_entity).obj(),
-      ConvertUTF8ToJavaString(env, scope).obj());
+      env, java_ref_, request_id,
+      ConvertUTF8ToJavaString(env, authorized_entity),
+      ConvertUTF8ToJavaString(env, scope));
 }
 
 void InstanceIDAndroid::DeleteIDImpl(const DeleteIDCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   int32_t request_id = delete_id_callbacks_.Add(new DeleteIDCallback(callback));
 
   JNIEnv* env = AttachCurrentThread();
-  Java_InstanceIDBridge_deleteInstanceID(env, java_ref_.obj(), request_id);
+  Java_InstanceIDBridge_deleteInstanceID(env, java_ref_, request_id);
 }
 
 void InstanceIDAndroid::DidGetID(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     jint request_id,
     const base::android::JavaParamRef<jstring>& jid) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   GetIDCallback* callback = get_id_callbacks_.Lookup(request_id);
@@ skipping 59 matching lines @@
     jboolean success) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DeleteIDCallback* callback = delete_id_callbacks_.Lookup(request_id);
   DCHECK(callback);
   callback->Run(success ? InstanceID::SUCCESS : InstanceID::UNKNOWN_ERROR);
   delete_id_callbacks_.Remove(request_id);
 }
 
 }  // namespace instance_id