[Clank] Load/Remove persistent license

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 106 matching lines @@
     case RequestType::REQUEST_TYPE_RENEWAL:
       return ContentDecryptionModule::LICENSE_RENEWAL;
     case RequestType::REQUEST_TYPE_RELEASE:
       return ContentDecryptionModule::LICENSE_RELEASE;
   }
 
   NOTREACHED();
   return ContentDecryptionModule::LICENSE_REQUEST;
 }
 
-CdmKeyInformation::KeyStatus ConvertKeyStatus(KeyStatus key_status) {
+CdmKeyInformation::KeyStatus ConvertKeyStatus(KeyStatus key_status,
+                                              bool is_key_release) {
   switch (key_status) {
     case KeyStatus::KEY_STATUS_USABLE:
       return CdmKeyInformation::USABLE;
     case KeyStatus::KEY_STATUS_EXPIRED:
-      return CdmKeyInformation::EXPIRED;
+      return is_key_release ? CdmKeyInformation::RELEASED
+                            : CdmKeyInformation::EXPIRED;
     case KeyStatus::KEY_STATUS_OUTPUT_NOT_ALLOWED:
       return CdmKeyInformation::OUTPUT_RESTRICTED;
     case KeyStatus::KEY_STATUS_PENDING:
       // TODO(xhwang): This should probably be renamed to "PENDING".
       return CdmKeyInformation::KEY_STATUS_PENDING;
     case KeyStatus::KEY_STATUS_INTERNAL_ERROR:
       return CdmKeyInformation::INTERNAL_ERROR;
   }
 
   NOTREACHED();
@@ skipping 106 matching lines @@
   int32_t os_minor_version = 0;
   int32_t os_bugfix_version = 0;
   base::SysInfo::OperatingSystemVersionNumbers(
       &os_major_version, &os_minor_version, &os_bugfix_version);
   if (os_major_version == 4 && os_minor_version == 4 && os_bugfix_version == 0)
     return false;
 
   return true;
 }
 
+bool IsPersistentLicenseTypeSupportedByMediaDrm() {
+  return MediaDrmBridge::IsAvailable() &&
+         base::FeatureList::IsEnabled(kMediaDrmPersistentLicense) &&
+         base::android::BuildInfo::GetInstance()->sdk_int() >= 23;
+}
+
 }  // namespace
 
 // MediaDrm is not generally usable without MediaCodec. Thus, both the MediaDrm
 // APIs and MediaCodec APIs must be enabled and not blacklisted.
 // static
 bool MediaDrmBridge::IsAvailable() {
   return AreMediaDrmApisAvailable() && MediaCodecUtil::IsMediaCodecAvailable();
 }
 
 // static
 bool MediaDrmBridge::RegisterMediaDrmBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 // static
 bool MediaDrmBridge::IsKeySystemSupported(const std::string& key_system) {
   if (!MediaDrmBridge::IsAvailable())
     return false;
 
   return IsKeySystemSupportedWithTypeImpl(key_system, "");
 }
 
 // static
 bool MediaDrmBridge::IsPersistentLicenseTypeSupported(
     const std::string& key_system) {
-  if (!MediaDrmBridge::IsAvailable())
+  if (!IsPersistentLicenseTypeSupportedByMediaDrm())
     return false;
 
-  if (!base::FeatureList::IsEnabled(kMediaDrmPersistentLicense)) {
-    return false;
-  }
-
   NOTIMPLEMENTED() << "In development. See http://crbug.com/493521";

[xhwang, 2017/04/06 04:41:30]

You can move this to a comment on line 263. Then this function can just be:

return IsPersistentLicenseTypeSupportedByMediaDrm();

[yucliu1, 2017/04/06 16:47:24]

Done.

   return false;
 }
 
 // static
 bool MediaDrmBridge::IsKeySystemSupportedWithType(
     const std::string& key_system,
     const std::string& container_mime_type) {
   DCHECK(!container_mime_type.empty()) << "Call IsKeySystemSupported instead";
 
   if (!MediaDrmBridge::IsAvailable())
@@ skipping 151 matching lines @@
       promise_id);
 }
 
 void MediaDrmBridge::LoadSession(
     CdmSessionType session_type,
     const std::string& session_id,
     std::unique_ptr<media::NewSessionCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(2) << __func__;
 
-  DCHECK(base::FeatureList::IsEnabled(kMediaDrmPersistentLicense));
+  DCHECK(IsPersistentLicenseTypeSupportedByMediaDrm());
 
-  NOTIMPLEMENTED() << "EME persistent sessions not yet supported on Android.";
-  promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
-                  "LoadSession() is not supported.");
+  if (session_type != CdmSessionType::PERSISTENT_LICENSE_SESSION) {
+    promise->reject(
+        CdmPromise::NOT_SUPPORTED_ERROR, 0,
+        "LoadSession() is only supported for 'persistent-license'.");
+    return;
+  }
+
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jbyteArray> j_session_id =
+      StringToJavaBytes(env, session_id);
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
+  Java_MediaDrmBridge_loadSession(env, j_media_drm_, j_session_id, promise_id);
 }
 
 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) << __func__;
 
   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());
+  ScopedJavaLocalRef<jbyteArray> j_session_id =
+      StringToJavaBytes(env, session_id);
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   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) << __func__;
 
   JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jbyteArray> j_session_id = base::android::ToJavaByteArray(
-      env, reinterpret_cast<const uint8_t*>(session_id.data()),
-      session_id.size());
+  ScopedJavaLocalRef<jbyteArray> j_session_id =
+      StringToJavaBytes(env, session_id);
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   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) << __func__;
 
-  NOTIMPLEMENTED() << "EME persistent sessions not yet supported on Android.";
-  promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
-                  "RemoveSession() is not supported.");
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jbyteArray> j_session_id =
+      StringToJavaBytes(env, session_id);
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
+  Java_MediaDrmBridge_removeSession(env, j_media_drm_, j_session_id,
+                                    promise_id);
 }
 
 CdmContext* MediaDrmBridge::GetCdmContext() {
   DVLOG(2) << __func__;
 
   return &media_drm_bridge_cdm_context_;
 }
 
 void MediaDrmBridge::DeleteOnCorrectThread() const {
   DVLOG(1) << __func__;
@@ skipping 170 matching lines @@
   DVLOG(2) << __func__;
   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) {
+    bool has_additional_usable_key,
+    bool is_key_release) {
   DVLOG(2) << __func__;
 
   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);
     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);
     CdmKeyInformation::KeyStatus key_status =
-        ConvertKeyStatus(static_cast<KeyStatus>(j_status_code));
+        ConvertKeyStatus(static_cast<KeyStatus>(j_status_code), is_key_release);
 
     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,
@@ skipping 177 matching lines @@
   DVLOG(1) << __func__;
 
   DCHECK(provision_fetcher_) << "No provision request pending.";
   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());
+  ScopedJavaLocalRef<jbyteArray> j_response = StringToJavaBytes(env, response);
 
   Java_MediaDrmBridge_processProvisionResponse(env, j_media_drm_, success,
                                                j_response);
 }
 
 void MediaDrmBridge::OnHasAdditionalUsableKey() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __func__;
 
   player_tracker_.NotifyNewKey();
 }
 
 }  // namespace media