media: Pass MediaPermission to MediaDrmBridge

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 11 matching lines @@
 #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/thread_task_runner_handle.h"
 #include "jni/MediaDrmBridge_jni.h"
 #include "media/base/android/media_client_android.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/android/media_drm_bridge_delegate.h"
 #include "media/base/android/provision_fetcher.h"
+#include "media/base/media_permission.h"
 #include "media/base/cdm_key_information.h"
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::JavaByteArrayToByteVector;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 
@@ skipping 25 matching lines @@
   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) {
+std::string ConvertInitDataType(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.
   switch (init_data_type) {
-    case media::EmeInitDataType::WEBM:
+    case EmeInitDataType::WEBM:
       return "video/webm";
-    case media::EmeInitDataType::CENC:
+    case EmeInitDataType::CENC:
       return "video/mp4";
-    case media::EmeInitDataType::KEYIDS:
+    case EmeInitDataType::KEYIDS:
       return "keyids";
     default:
       NOTREACHED();
       return "unknown";
   }
 }
 
 MediaKeys::MessageType GetMessageType(RequestType request_type) {
   switch (request_type) {
     case RequestType::REQUEST_TYPE_INITIAL:
@@ skipping 176 matching lines @@
 std::vector<std::string> MediaDrmBridge::GetPlatformKeySystemNames() {
   if (!MediaDrmBridge::IsAvailable())
     return std::vector<std::string>();
 
   return g_key_system_manager.Get().GetPlatformKeySystemNames();
 }
 
 // static
 scoped_refptr<MediaDrmBridge> MediaDrmBridge::CreateInternal(
     const std::string& key_system,
+    const GURL& security_origin,
     SecurityLevel security_level,
+    MediaPermission* media_permission,
     const CreateFetcherCB& create_fetcher_cb,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
     const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb) {
   // All paths requires the MediaDrmApis.
   DCHECK(AreMediaDrmApisAvailable());
 
   UUID scheme_uuid = g_key_system_manager.Get().GetUUID(key_system);
   if (scheme_uuid.empty())
     return nullptr;
 
   scoped_refptr<MediaDrmBridge> media_drm_bridge(new MediaDrmBridge(
-      scheme_uuid, security_level, create_fetcher_cb, session_message_cb,
-      session_closed_cb, legacy_session_error_cb, session_keys_change_cb,
+      scheme_uuid, security_origin, security_level, media_permission,
+      create_fetcher_cb, session_message_cb, session_closed_cb,
+      legacy_session_error_cb, session_keys_change_cb,
       session_expiration_update_cb));
 
   if (media_drm_bridge->j_media_drm_.is_null())
     media_drm_bridge = nullptr;
 
   return media_drm_bridge;
 }
 
 // static
 scoped_refptr<MediaDrmBridge> MediaDrmBridge::Create(
     const std::string& key_system,
+    const GURL& security_origin,
     SecurityLevel security_level,
+    MediaPermission* media_permission,
     const CreateFetcherCB& create_fetcher_cb,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
     const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb) {
   DVLOG(1) << __FUNCTION__;
 
   if (!IsAvailable())
     return nullptr;
 
-  return CreateInternal(key_system, security_level, create_fetcher_cb,
-                        session_message_cb, session_closed_cb,
-                        legacy_session_error_cb, session_keys_change_cb,
-                        session_expiration_update_cb);
+  return CreateInternal(key_system, security_origin, security_level,
+                        media_permission, create_fetcher_cb, session_message_cb,
+                        session_closed_cb, legacy_session_error_cb,
+                        session_keys_change_cb, session_expiration_update_cb);
 }
 
 // static
 scoped_refptr<MediaDrmBridge> MediaDrmBridge::CreateWithoutSessionSupport(
     const std::string& key_system,
     SecurityLevel security_level,
     const CreateFetcherCB& create_fetcher_cb) {
   DVLOG(1) << __FUNCTION__;
 
   // Sessions won't be used so decoding capability is not required.
   if (!AreMediaDrmApisAvailable())
     return nullptr;
 
-  return MediaDrmBridge::Create(key_system, security_level, create_fetcher_cb,
-                                SessionMessageCB(), SessionClosedCB(),
-                                LegacySessionErrorCB(), SessionKeysChangeCB(),
-                                SessionExpirationUpdateCB());
+  return MediaDrmBridge::Create(
+      key_system, GURL(), security_level, nullptr, create_fetcher_cb,
+      SessionMessageCB(), SessionClosedCB(), LegacySessionErrorCB(),
+      SessionKeysChangeCB(), SessionExpirationUpdateCB());
 }
 
 void MediaDrmBridge::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
-    scoped_ptr<media::SimpleCdmPromise> promise) {
+    scoped_ptr<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())) {
     promise->resolve();
   } else {
     promise->reject(INVALID_ACCESS_ERROR, 0, "Set server certificate failed.");
   }
 }
 
 void MediaDrmBridge::CreateSessionAndGenerateRequest(
     SessionType session_type,
-    media::EmeInitDataType init_data_type,
+    EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
-    scoped_ptr<media::NewSessionCdmPromise> promise) {
+    scoped_ptr<NewSessionCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(2) << __FUNCTION__;
 
-  if (session_type != media::MediaKeys::TEMPORARY_SESSION) {
+  if (session_type != MediaKeys::TEMPORARY_SESSION) {
     NOTIMPLEMENTED() << "EME persistent sessions not yet supported on Android.";
     promise->reject(NOT_SUPPORTED_ERROR, 0,
                     "Only the temporary session type is supported.");
     return;
   }
 
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jbyteArray> j_init_data;
-  ScopedJavaLocalRef<jobjectArray> j_optional_parameters;
-
-  MediaClientAndroid* client = GetMediaClientAndroid();
-  if (client) {
-    MediaDrmBridgeDelegate* delegate =
-        client->GetMediaDrmBridgeDelegate(scheme_uuid_);
-    if (delegate) {
-      std::vector<uint8_t> init_data_from_delegate;
-      std::vector<std::string> optional_parameters_from_delegate;
-      if (!delegate->OnCreateSession(init_data_type, init_data,
-                                     &init_data_from_delegate,
-                                     &optional_parameters_from_delegate)) {
-        promise->reject(INVALID_ACCESS_ERROR, 0, "Invalid init data.");
-        return;
-      }
-      if (!init_data_from_delegate.empty()) {
-        j_init_data =
-            base::android::ToJavaByteArray(env, init_data_from_delegate.data(),
-                                           init_data_from_delegate.size());
-      }
-      if (!optional_parameters_from_delegate.empty()) {
-        j_optional_parameters = base::android::ToJavaArrayOfStrings(
-            env, optional_parameters_from_delegate);
-      }
-    }
+  // TODO(xhwang): |media_permission_| is optional here because when running
+  // in the browser process BrowserCdmManager does the permission check. Make
+  // |media_permission_| mandatory when BrowserCdmManager is deprecated.
+  // See http://crbug.com/581746
+  if (!media_permission_) {
+    CreateSessionAndGenerateRequestIfPermitted(init_data_type, init_data,
+                                               std::move(promise), true);
+  } else {
+    media_permission_->HasPermission(
+        MediaPermission::PROTECTED_MEDIA_IDENTIFIER, security_origin_,
+        base::Bind(&MediaDrmBridge::CreateSessionAndGenerateRequestIfPermitted,
+                   weak_factory_.GetWeakPtr(), init_data_type, init_data,
+                   base::Passed(&promise)));
   }
-
-  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);
 }
 
-void MediaDrmBridge::LoadSession(
-    SessionType session_type,
-    const std::string& session_id,
-    scoped_ptr<media::NewSessionCdmPromise> promise) {
+void MediaDrmBridge::LoadSession(SessionType session_type,
+                                 const std::string& session_id,
+                                 scoped_ptr<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,
-    scoped_ptr<media::SimpleCdmPromise> promise) {
+void MediaDrmBridge::UpdateSession(const std::string& session_id,
+                                   const std::vector<uint8_t>& response,
+                                   scoped_ptr<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);
 }
 
 void MediaDrmBridge::CloseSession(const std::string& session_id,
-                                  scoped_ptr<media::SimpleCdmPromise> promise) {
+                                  scoped_ptr<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);
 }
 
-void MediaDrmBridge::RemoveSession(
-    const std::string& session_id,
-    scoped_ptr<media::SimpleCdmPromise> promise) {
+void MediaDrmBridge::RemoveSession(const std::string& session_id,
+                                   scoped_ptr<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.");
 }
 
 CdmContext* MediaDrmBridge::GetCdmContext() {
   DVLOG(2) << __FUNCTION__;
 
@@ skipping 277 matching lines @@
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(base::ResetAndReturn(&reset_credentials_cb_), success));
 }
 
 //------------------------------------------------------------------------------
 // The following are private methods.
 
 MediaDrmBridge::MediaDrmBridge(
     const std::vector<uint8_t>& scheme_uuid,
+    const GURL& security_origin,
     SecurityLevel security_level,
+    MediaPermission* media_permission,
     const CreateFetcherCB& create_fetcher_cb,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
     const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb)
     : scheme_uuid_(scheme_uuid),
+      security_origin_(security_origin),
+      media_permission_(media_permission),
       create_fetcher_cb_(create_fetcher_cb),
       session_message_cb_(session_message_cb),
       session_closed_cb_(session_closed_cb),
       legacy_session_error_cb_(legacy_session_error_cb),
       session_keys_change_cb_(session_keys_change_cb),
       session_expiration_update_cb_(session_expiration_update_cb),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       media_drm_bridge_cdm_context_(this),
       weak_factory_(this) {
   DVLOG(1) << __FUNCTION__;
@@ skipping 72 matching lines @@
   j_media_crypto_ = std::move(j_media_crypto);
 
   if (media_crypto_ready_cb_.is_null())
     return;
 
   base::ResetAndReturn(&media_crypto_ready_cb_)
       .Run(CreateJavaObjectPtr(j_media_crypto_->obj()),
            IsProtectedSurfaceRequired());
 }
 
+void MediaDrmBridge::CreateSessionAndGenerateRequestIfPermitted(
+    EmeInitDataType init_data_type,
+    const std::vector<uint8_t>& init_data,
+    scoped_ptr<NewSessionCdmPromise> promise,
+    bool permitted) {
+  if (!permitted) {
+    promise->reject(MediaKeys::NOT_SUPPORTED_ERROR, 0, "Permission denied.");
+    return;
+  }
+
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jbyteArray> j_init_data;
+  ScopedJavaLocalRef<jobjectArray> j_optional_parameters;
+
+  MediaClientAndroid* client = GetMediaClientAndroid();
+  if (client) {
+    MediaDrmBridgeDelegate* delegate =
+        client->GetMediaDrmBridgeDelegate(scheme_uuid_);
+    if (delegate) {
+      std::vector<uint8_t> init_data_from_delegate;
+      std::vector<std::string> optional_parameters_from_delegate;
+      if (!delegate->OnCreateSession(init_data_type, init_data,
+                                     &init_data_from_delegate,
+                                     &optional_parameters_from_delegate)) {
+        promise->reject(INVALID_ACCESS_ERROR, 0, "Invalid init data.");
+        return;
+      }
+      if (!init_data_from_delegate.empty()) {
+        j_init_data =
+            base::android::ToJavaByteArray(env, init_data_from_delegate.data(),
+                                           init_data_from_delegate.size());
+      }
+      if (!optional_parameters_from_delegate.empty()) {
+        j_optional_parameters = base::android::ToJavaArrayOfStrings(
+            env, optional_parameters_from_delegate);
+      }
+    }
+  }
+
+  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);
+}
+
 void MediaDrmBridge::SendProvisioningRequest(const std::string& default_url,
                                              const std::string& request_data) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   DCHECK(!provision_fetcher_) << "At most one provision request at any time.";
   provision_fetcher_ = create_fetcher_cb_.Run();
 
   provision_fetcher_->Retrieve(
       default_url, request_data,
@@ skipping 22 matching lines @@
 }
 
 void MediaDrmBridge::OnHasAdditionalUsableKey() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   player_tracker_.NotifyNewKey();
 }
 
 }  // namespace media