[Clank] Add JNI interface for media persistent license storage

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>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/containers/hash_tables.h"
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/sys_byteorder.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "jni/MediaDrmBridge_jni.h"
+#include "media/base/android/android_util.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/android/media_drm_bridge_client.h"
 #include "media/base/android/media_drm_bridge_delegate.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/media_switches.h"
 #include "media/base/provision_fetcher.h"
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
@@ skipping 26 matching lines @@
 };
 
 // These must be in sync with Android MediaDrm KEY_TYPE_XXX constants:
 // https://developer.android.com/reference/android/media/MediaDrm.html#KEY_TYPE_OFFLINE
 // KEY_TYPE_RELEASE is handled internally in Java.
 enum class KeyType : uint32_t {
   KEY_TYPE_STREAMING = 1,
   KEY_TYPE_OFFLINE = 2,
 };
 
-// Converts jbyteArray (byte[] in Java) into std::string.
-std::string AsString(JNIEnv* env, jbyteArray j_byte_array) {
-  std::vector<uint8_t> byte_vector;
-  JavaByteArrayToByteVector(env, j_byte_array, &byte_vector);
-  return std::string(byte_vector.begin(), byte_vector.end());
-}
-
 const uint8_t kWidevineUuid[16] = {
     0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE,  //
     0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED};
 
 // Convert |init_data_type| to a string supported by MediaDRM.
 // "audio"/"video" does not matter, so use "video".
 std::string ConvertInitDataType(media::EmeInitDataType init_data_type) {
   // TODO(jrummell/xhwang): EME init data types like "webm" and "cenc" are
   // supported in API level >=21 for Widevine key system. Switch to use those
   // strings when they are officially supported in Android for all key systems.
@@ skipping 538 matching lines @@
     JNIEnv* env,
     const JavaParamRef<jobject>& j_media_drm,
     const JavaParamRef<jstring>& j_default_url,
     const JavaParamRef<jbyteArray>& j_request_data) {
   DVLOG(1) << __func__;
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&MediaDrmBridge::SendProvisioningRequest,
                                     weak_factory_.GetWeakPtr(),
                                     ConvertJavaStringToUTF8(env, j_default_url),
-                                    AsString(env, j_request_data)));
+                                    JavaBytesToString(env, j_request_data)));
 }
 
 void MediaDrmBridge::OnPromiseResolved(JNIEnv* env,
                                        const JavaParamRef<jobject>& j_media_drm,
                                        jint j_promise_id) {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&MediaDrmBridge::ResolvePromise,
                                     weak_factory_.GetWeakPtr(), j_promise_id));
 }
 
 void MediaDrmBridge::OnPromiseResolvedWithSession(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_media_drm,
     jint j_promise_id,
     const JavaParamRef<jbyteArray>& j_session_id) {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&MediaDrmBridge::ResolvePromiseWithSession,
                                     weak_factory_.GetWeakPtr(), j_promise_id,
-                                    AsString(env, j_session_id)));
+                                    JavaBytesToString(env, j_session_id)));
 }
 
 void MediaDrmBridge::OnPromiseRejected(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_media_drm,
     jint j_promise_id,
     const JavaParamRef<jstring>& j_error_message) {
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MediaDrmBridge::RejectPromise, weak_factory_.GetWeakPtr(),
                  j_promise_id, ConvertJavaStringToUTF8(env, j_error_message)));
 }
 
 void MediaDrmBridge::OnSessionMessage(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_media_drm,
     const JavaParamRef<jbyteArray>& j_session_id,
     jint j_message_type,
     const JavaParamRef<jbyteArray>& j_message) {
   DVLOG(2) << __func__;
 
   std::vector<uint8_t> message;
   JavaByteArrayToByteVector(env, j_message, &message);
   ContentDecryptionModule::MessageType message_type =
       GetMessageType(static_cast<RequestType>(j_message_type));
 
   task_runner_->PostTask(
-      FROM_HERE, base::Bind(session_message_cb_, AsString(env, j_session_id),
-                            message_type, message));
+      FROM_HERE,
+      base::Bind(session_message_cb_, JavaBytesToString(env, j_session_id),
+                 message_type, message));
 }
 
 void MediaDrmBridge::OnSessionClosed(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_media_drm,
     const JavaParamRef<jbyteArray>& j_session_id) {
   DVLOG(2) << __func__;
-  std::string session_id = AsString(env, j_session_id);
+  std::string session_id = JavaBytesToString(env, j_session_id);
   task_runner_->PostTask(FROM_HERE, base::Bind(session_closed_cb_, session_id));
 }
 
 void MediaDrmBridge::OnSessionKeysChange(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_media_drm,
     const JavaParamRef<jbyteArray>& j_session_id,
     const JavaParamRef<jobjectArray>& j_keys_info,
     bool has_additional_usable_key) {
   DVLOG(2) << __func__;
@@ skipping 19 matching lines @@
 
     DVLOG(2) << __func__ << "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));
   }
 
   task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(session_keys_change_cb_, AsString(env, j_session_id),
+      base::Bind(session_keys_change_cb_, JavaBytesToString(env, j_session_id),
                  has_additional_usable_key, base::Passed(&cdm_keys_info)));
 
   if (has_additional_usable_key) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&MediaDrmBridge::OnHasAdditionalUsableKey,
                                       weak_factory_.GetWeakPtr()));
   }
 }
 
 // According to MeidaDrm documentation [1], zero |expiry_time_ms| means the keys
 // will never expire. This will be translated into a NULL base::Time() [2],
 // which will then be mapped to a zero Java time [3]. The zero Java time is
 // passed to Blink which will then be translated to NaN [4], which is what the
 // spec uses to indicate that the license will never expire [5].
 // [1]
 // http://developer.android.com/reference/android/media/MediaDrm.OnExpirationUpdateListener.html
 // [2] See base::Time::FromDoubleT()
 // [3] See base::Time::ToJavaTime()
 // [4] See MediaKeySession::expirationChanged()
 // [5] https://github.com/w3c/encrypted-media/issues/58
 void MediaDrmBridge::OnSessionExpirationUpdate(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_media_drm,
     const JavaParamRef<jbyteArray>& j_session_id,
     jlong expiry_time_ms) {
   DVLOG(2) << __func__ << ": " << expiry_time_ms << " ms";
   task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(session_expiration_update_cb_, AsString(env, j_session_id),
-                 base::Time::FromDoubleT(expiry_time_ms / 1000.0)));
+      FROM_HERE, base::Bind(session_expiration_update_cb_,
+                            JavaBytesToString(env, j_session_id),
+                            base::Time::FromDoubleT(expiry_time_ms / 1000.0)));
 }
 
 void MediaDrmBridge::OnResetDeviceCredentialsCompleted(
     JNIEnv* env,
     const JavaParamRef<jobject>&,
     bool success) {
   DVLOG(2) << __func__ << ": success:" << success;
   DCHECK(!reset_credentials_cb_.is_null());
   task_runner_->PostTask(
       FROM_HERE,
@@ skipping 44 matching lines @@
 
   // TODO(yucliu): Per EME spec on individualization, implementation should not
   // expose application-specific information. Considering encode origin before
   // passing to MediaDrm.
   ScopedJavaLocalRef<jstring> j_security_origin = ConvertUTF8ToJavaString(
       env, use_origin_isolated_storage ? security_origin.spec() : "");
 
   // Note: OnMediaCryptoReady() could be called in this call.
   j_media_drm_.Reset(Java_MediaDrmBridge_create(
       env, j_scheme_uuid, j_security_origin, j_security_level,
-      reinterpret_cast<intptr_t>(this)));
+      reinterpret_cast<intptr_t>(this), reinterpret_cast<intptr_t>(&storage_)));
 }
 
 MediaDrmBridge::~MediaDrmBridge() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __func__;
 
   JNIEnv* env = AttachCurrentThread();
 
   // After the call to Java_MediaDrmBridge_destroy() Java won't call native
   // methods anymore, this is ensured by MediaDrmBridge.java.
@@ skipping 20 matching lines @@
 
 MediaDrmBridge::SecurityLevel MediaDrmBridge::GetSecurityLevel() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_security_level =
       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) {
-  JavaObjectPtr j_object_ptr(new ScopedJavaGlobalRef<jobject>());
-  j_object_ptr->Reset(AttachCurrentThread(), object);
-  return j_object_ptr;
-}
-
 void MediaDrmBridge::NotifyMediaCryptoReady(JavaObjectPtr j_media_crypto) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(j_media_crypto);
   DCHECK(!j_media_crypto_);
 
   j_media_crypto_ = std::move(j_media_crypto);
 
   if (media_crypto_ready_cb_.is_null())
     return;
 
+  // We have to use scoped_ptr to pass ScopedJavaGlobalRef with a callback.
+  // TODO(yucliu): Check whether we can simply pass j_media_crypto_->obj() in the
+  // callback.
   base::ResetAndReturn(&media_crypto_ready_cb_)
       .Run(CreateJavaObjectPtr(j_media_crypto_->obj()),
            IsProtectedSurfaceRequired());
 }
 
 void MediaDrmBridge::SendProvisioningRequest(const std::string& default_url,
                                              const std::string& request_data) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __func__;
 
@@ skipping 27 matching lines @@
 }
 
 void MediaDrmBridge::OnHasAdditionalUsableKey() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __func__;
 
   player_tracker_.NotifyNewKey();
 }
 
 }  // namespace media