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

remoting/client/jni/jni_client.cc

 // Copyright 2016 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 "remoting/client/jni/jni_client.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/logging.h"
 #include "jni/Client_jni.h"
@@ skipping 68 matching lines @@
     runtime_->display_task_runner()->DeleteSoon(FROM_HERE,
                                                 display_handler_.release());
   }
 }
 
 void JniClient::OnConnectionState(protocol::ConnectionToHost::State state,
                                   protocol::ErrorCode error) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_Client_onConnectionState(env, java_client_.obj(), state, error);
+  Java_Client_onConnectionState(env, java_client_, state, error);
 }
 
 void JniClient::DisplayAuthenticationPrompt(bool pairing_supported) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_Client_displayAuthenticationPrompt(env, java_client_.obj(),
-                                          pairing_supported);
+  Java_Client_displayAuthenticationPrompt(env, java_client_, pairing_supported);
 }
 
 void JniClient::CommitPairingCredentials(const std::string& host,
                                          const std::string& id,
                                          const std::string& secret) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_host = ConvertUTF8ToJavaString(env, host);
   ScopedJavaLocalRef<jstring> j_id = ConvertUTF8ToJavaString(env, id);
   ScopedJavaLocalRef<jstring> j_secret = ConvertUTF8ToJavaString(env, secret);
 
-  Java_Client_commitPairingCredentials(env, java_client_.obj(), j_host.obj(),
-                                       j_id.obj(), j_secret.obj());
+  Java_Client_commitPairingCredentials(env, java_client_, j_host, j_id,
+                                       j_secret);
 }
 
 void JniClient::FetchThirdPartyToken(const std::string& token_url,
                                      const std::string& client_id,
                                      const std::string& scope) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
   JNIEnv* env = base::android::AttachCurrentThread();
 
   ScopedJavaLocalRef<jstring> j_url = ConvertUTF8ToJavaString(env, token_url);
   ScopedJavaLocalRef<jstring> j_client_id =
       ConvertUTF8ToJavaString(env, client_id);
   ScopedJavaLocalRef<jstring> j_scope = ConvertUTF8ToJavaString(env, scope);
 
-  Java_Client_fetchThirdPartyToken(env, java_client_.obj(), j_url.obj(),
-                                   j_client_id.obj(), j_scope.obj());
+  Java_Client_fetchThirdPartyToken(env, java_client_, j_url, j_client_id,
+                                   j_scope);
 }
 
 void JniClient::SetCapabilities(const std::string& capabilities) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
   JNIEnv* env = base::android::AttachCurrentThread();
 
   ScopedJavaLocalRef<jstring> j_cap =
       ConvertUTF8ToJavaString(env, capabilities);
 
-  Java_Client_setCapabilities(env, java_client_.obj(), j_cap.obj());
+  Java_Client_setCapabilities(env, java_client_, j_cap);
 }
 
 void JniClient::HandleExtensionMessage(const std::string& type,
                                        const std::string& message) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
   JNIEnv* env = base::android::AttachCurrentThread();
 
   ScopedJavaLocalRef<jstring> j_type = ConvertUTF8ToJavaString(env, type);
   ScopedJavaLocalRef<jstring> j_message = ConvertUTF8ToJavaString(env, message);
 
-  Java_Client_handleExtensionMessage(env, java_client_.obj(), j_type.obj(),
-                                     j_message.obj());
+  Java_Client_handleExtensionMessage(env, java_client_, j_type, j_message);
 }
 
 // static
 bool JniClient::RegisterJni(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 void JniClient::Connect(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& caller,
@@ skipping 141 matching lines @@
   return weak_ptr_;
 }
 
 static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& caller) {
   return reinterpret_cast<intptr_t>(
       new JniClient(ChromotingJniRuntime::GetInstance(),
                     base::android::ScopedJavaGlobalRef<jobject>(env, caller)));
 }
 
 }  // namespace remoting