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

media/base/android/media_drm_bridge.cc

 // Copyright (c) 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 "media/base/android/media_drm_bridge.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 174 matching lines @@
 
   UUID scheme_uuid = g_key_system_manager.Get().GetUUID(key_system);
   if (scheme_uuid.empty())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_scheme_uuid =
       base::android::ToJavaByteArray(env, &scheme_uuid[0], scheme_uuid.size());
   ScopedJavaLocalRef<jstring> j_container_mime_type =
       ConvertUTF8ToJavaString(env, container_mime_type);
-  return Java_MediaDrmBridge_isCryptoSchemeSupported(
-      env, j_scheme_uuid.obj(), j_container_mime_type.obj());
+  return Java_MediaDrmBridge_isCryptoSchemeSupported(env, j_scheme_uuid,
+                                                     j_container_mime_type);
 }
 
 MediaDrmBridge::SecurityLevel GetSecurityLevelFromString(
     const std::string& security_level_str) {
   if (0 == security_level_str.compare("L1"))
     return MediaDrmBridge::SECURITY_LEVEL_1;
   if (0 == security_level_str.compare("L3"))
     return MediaDrmBridge::SECURITY_LEVEL_3;
   DCHECK(security_level_str.empty());
   return MediaDrmBridge::SECURITY_LEVEL_DEFAULT;
@@ skipping 141 matching lines @@
     const std::vector<uint8_t>& certificate,
     std::unique_ptr<media::SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(2) << __FUNCTION__ << "(" << certificate.size() << " bytes)";
 
   DCHECK(!certificate.empty());
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_certificate = base::android::ToJavaByteArray(
       env, certificate.data(), certificate.size());
-  if (Java_MediaDrmBridge_setServerCertificate(env, j_media_drm_.obj(),
-                                               j_certificate.obj())) {
+  if (Java_MediaDrmBridge_setServerCertificate(env, j_media_drm_,
+                                               j_certificate)) {
     promise->resolve();
   } else {
     promise->reject(INVALID_ACCESS_ERROR, 0, "Set server certificate failed.");
   }
 }
 
 void MediaDrmBridge::CreateSessionAndGenerateRequest(
     SessionType session_type,
     media::EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
@@ skipping 38 matching lines @@
   }
 
   if (j_init_data.is_null()) {
     j_init_data =
         base::android::ToJavaByteArray(env, init_data.data(), init_data.size());
   }
 
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, ConvertInitDataType(init_data_type));
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
-  Java_MediaDrmBridge_createSessionFromNative(
-      env, j_media_drm_.obj(), j_init_data.obj(), j_mime.obj(),
-      j_optional_parameters.obj(), promise_id);
+  Java_MediaDrmBridge_createSessionFromNative(env, j_media_drm_, j_init_data,
+                                              j_mime, j_optional_parameters,
+                                              promise_id);
 }
 
 void MediaDrmBridge::LoadSession(
     SessionType session_type,
     const std::string& session_id,
     std::unique_ptr<media::NewSessionCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(2) << __FUNCTION__;
 
   NOTIMPLEMENTED() << "EME persistent sessions not yet supported on Android.";
   promise->reject(NOT_SUPPORTED_ERROR, 0, "LoadSession() is not supported.");
 }
 
 void MediaDrmBridge::UpdateSession(
     const std::string& session_id,
     const std::vector<uint8_t>& response,
     std::unique_ptr<media::SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(2) << __FUNCTION__;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_response =
       base::android::ToJavaByteArray(env, response.data(), response.size());
   ScopedJavaLocalRef<jbyteArray> j_session_id = base::android::ToJavaByteArray(
       env, reinterpret_cast<const uint8_t*>(session_id.data()),
       session_id.size());
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
-  Java_MediaDrmBridge_updateSession(env, j_media_drm_.obj(), j_session_id.obj(),
-                                    j_response.obj(), promise_id);
+  Java_MediaDrmBridge_updateSession(env, j_media_drm_, j_session_id, j_response,
+                                    promise_id);
 }
 
 void MediaDrmBridge::CloseSession(
     const std::string& session_id,
     std::unique_ptr<media::SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(2) << __FUNCTION__;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_session_id = base::android::ToJavaByteArray(
       env, reinterpret_cast<const uint8_t*>(session_id.data()),
       session_id.size());
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
-  Java_MediaDrmBridge_closeSession(env, j_media_drm_.obj(), j_session_id.obj(),
-                                   promise_id);
+  Java_MediaDrmBridge_closeSession(env, j_media_drm_, j_session_id, promise_id);
 }
 
 void MediaDrmBridge::RemoveSession(
     const std::string& session_id,
     std::unique_ptr<media::SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(2) << __FUNCTION__;
 
   NOTIMPLEMENTED() << "EME persistent sessions not yet supported on Android.";
   promise->reject(NOT_SUPPORTED_ERROR, 0, "RemoveSession() is not supported.");
@@ skipping 36 matching lines @@
   return true;
 }
 
 void MediaDrmBridge::ResetDeviceCredentials(
     const ResetCredentialsCB& callback) {
   DVLOG(1) << __FUNCTION__;
 
   DCHECK(reset_credentials_cb_.is_null());
   reset_credentials_cb_ = callback;
   JNIEnv* env = AttachCurrentThread();
-  Java_MediaDrmBridge_resetDeviceCredentials(env, j_media_drm_.obj());
+  Java_MediaDrmBridge_resetDeviceCredentials(env, j_media_drm_);
 }
 
 void MediaDrmBridge::ResolvePromise(uint32_t promise_id) {
   DVLOG(2) << __FUNCTION__;
   cdm_promise_adapter_.ResolvePromise(promise_id);
 }
 
 void MediaDrmBridge::ResolvePromiseWithSession(uint32_t promise_id,
                                                const std::string& session_id) {
   DVLOG(2) << __FUNCTION__;
@@ skipping 143 matching lines @@
   CdmKeysInfo cdm_keys_info;
 
   size_t size = env->GetArrayLength(j_keys_info);
   DCHECK_GT(size, 0u);
 
   for (size_t i = 0; i < size; ++i) {
     ScopedJavaLocalRef<jobject> j_key_status(
         env, env->GetObjectArrayElement(j_keys_info, i));
 
     ScopedJavaLocalRef<jbyteArray> j_key_id =
-        Java_KeyStatus_getKeyId(env, j_key_status.obj());
+        Java_KeyStatus_getKeyId(env, j_key_status);
     std::vector<uint8_t> key_id;
     JavaByteArrayToByteVector(env, j_key_id.obj(), &key_id);
     DCHECK(!key_id.empty());
 
-    jint j_status_code = Java_KeyStatus_getStatusCode(env, j_key_status.obj());
+    jint j_status_code = Java_KeyStatus_getStatusCode(env, j_key_status);
     CdmKeyInformation::KeyStatus key_status =
         ConvertKeyStatus(static_cast<KeyStatus>(j_status_code));
 
     DVLOG(2) << __FUNCTION__ << "Key status change: "
              << base::HexEncode(&key_id[0], key_id.size()) << ", "
              << key_status;
 
     cdm_keys_info.push_back(new CdmKeyInformation(key_id, key_status, 0));
   }
 
@@ skipping 89 matching lines @@
 
   ScopedJavaLocalRef<jbyteArray> j_scheme_uuid =
       base::android::ToJavaByteArray(env, &scheme_uuid[0], scheme_uuid.size());
 
   std::string security_level_str = GetSecurityLevelString(security_level);
   ScopedJavaLocalRef<jstring> j_security_level =
       ConvertUTF8ToJavaString(env, security_level_str);
 
   // Note: OnMediaCryptoReady() could be called in this call.
   j_media_drm_.Reset(Java_MediaDrmBridge_create(
-      env, j_scheme_uuid.obj(), j_security_level.obj(),
-      reinterpret_cast<intptr_t>(this)));
+      env, j_scheme_uuid, j_security_level, reinterpret_cast<intptr_t>(this)));
 }
 
 MediaDrmBridge::~MediaDrmBridge() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   JNIEnv* env = AttachCurrentThread();
 
   // After the call to Java_MediaDrmBridge_destroy() Java won't call native
   // methods anymore, this is ensured by MediaDrmBridge.java.
   if (!j_media_drm_.is_null())
-    Java_MediaDrmBridge_destroy(env, j_media_drm_.obj());
+    Java_MediaDrmBridge_destroy(env, j_media_drm_);
 
   player_tracker_.NotifyCdmUnset();
 
   if (!media_crypto_ready_cb_.is_null()) {
     base::ResetAndReturn(&media_crypto_ready_cb_)
         .Run(CreateJavaObjectPtr(nullptr), IsProtectedSurfaceRequired());
   }
 
   // Rejects all pending promises.
   cdm_promise_adapter_.Clear();
 }
 
 // TODO(ddorwin): This is specific to Widevine. http://crbug.com/459400
 // static
 bool MediaDrmBridge::IsSecureDecoderRequired(SecurityLevel security_level) {
   DCHECK(IsAvailable());
   return SECURITY_LEVEL_1 == security_level;
 }
 
 MediaDrmBridge::SecurityLevel MediaDrmBridge::GetSecurityLevel() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_security_level =
-      Java_MediaDrmBridge_getSecurityLevel(env, j_media_drm_.obj());
+      Java_MediaDrmBridge_getSecurityLevel(env, j_media_drm_);
   std::string security_level_str =
       ConvertJavaStringToUTF8(env, j_security_level.obj());
   return GetSecurityLevelFromString(security_level_str);
 }
 
 // We have to use scoped_ptr to pass ScopedJavaGlobalRef with a callback.
 // TODO(timav): Check whether we can simply pass j_media_crypto_->obj() in the
 // callback.
 MediaDrmBridge::JavaObjectPtr MediaDrmBridge::CreateJavaObjectPtr(
     jobject object) {
@@ skipping 40 matching lines @@
   provision_fetcher_.reset();
 
   if (!success)
     VLOG(1) << "Device provision failure: can't get server response";
 
   JNIEnv* env = AttachCurrentThread();
 
   ScopedJavaLocalRef<jbyteArray> j_response = base::android::ToJavaByteArray(
       env, reinterpret_cast<const uint8_t*>(response.data()), response.size());
 
-  Java_MediaDrmBridge_processProvisionResponse(env, j_media_drm_.obj(), success,
-                                               j_response.obj());
+  Java_MediaDrmBridge_processProvisionResponse(env, j_media_drm_, success,
+                                               j_response);
 }
 
 void MediaDrmBridge::OnHasAdditionalUsableKey() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   player_tracker_.NotifyNewKey();
 }
 
 }  // namespace media