Move MediaDrmBridge provision communication to native side.

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 <algorithm>
 
 #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/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.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/thread_task_runner_handle.h"
 #include "jni/MediaDrmBridge_jni.h"
 #include "media/base/android/media_client_android.h"
 #include "media/base/android/media_drm_bridge_delegate.h"
+#include "media/base/android/provision_fetcher.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 13 matching lines @@
 // These must be in sync with Android MediaDrm KEY_STATUS_XXX constants:
 // https://developer.android.com/reference/android/media/MediaDrm.KeyStatus.html
 enum class KeyStatus {
   KEY_STATUS_USABLE = 0,
   KEY_STATUS_EXPIRED = 1,
   KEY_STATUS_OUTPUT_NOT_ALLOWED = 2,
   KEY_STATUS_PENDING = 3,
   KEY_STATUS_INTERNAL_ERROR = 4,
 };
 
-// Returns string session ID from jbyteArray (byte[] in Java).
-std::string GetSessionId(JNIEnv* env, jbyteArray j_session_id) {
-  std::vector<uint8> session_id_vector;
-  JavaByteArrayToByteVector(env, j_session_id, &session_id_vector);
-  return std::string(session_id_vector.begin(), session_id_vector.end());
+// 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 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
@@ skipping 173 matching lines @@
 }
 
 // static
 std::vector<std::string> MediaDrmBridge::GetPlatformKeySystemNames() {
   return g_key_system_manager.Get().GetPlatformKeySystemNames();
 }
 
 // static
 scoped_refptr<MediaDrmBridge> MediaDrmBridge::Create(
     const std::string& key_system,
+    scoped_ptr<ProvisionFetcher> provision_fetcher,
     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;
 
   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, session_message_cb, session_closed_cb,
+      new MediaDrmBridge(scheme_uuid, provision_fetcher.Pass(),
+                         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::CreateWithoutSessionSupport(
-    const std::string& key_system) {
-  return MediaDrmBridge::Create(
-      key_system, SessionMessageCB(), SessionClosedCB(), LegacySessionErrorCB(),
-      SessionKeysChangeCB(), SessionExpirationUpdateCB());
+    const std::string& key_system,
+    scoped_ptr<ProvisionFetcher> provision_fetcher) {
+  return MediaDrmBridge::Create(key_system, provision_fetcher.Pass(),
+                                SessionMessageCB(), SessionClosedCB(),
+                                LegacySessionErrorCB(), SessionKeysChangeCB(),
+                                SessionExpirationUpdateCB());
 }
 
 void MediaDrmBridge::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
     scoped_ptr<media::SimpleCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
 
   DCHECK(!certificate.empty());
 
   JNIEnv* env = AttachCurrentThread();
@@ skipping 156 matching lines @@
   // For Widevine, this depends on the security level.
   if (std::equal(scheme_uuid_.begin(), scheme_uuid_.end(), kWidevineUuid))
     return IsSecureDecoderRequired(GetSecurityLevel());
 
   // For other key systems, assume true.
   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());
 }
 
 void MediaDrmBridge::ResolvePromise(uint32_t promise_id) {
   DVLOG(2) << __FUNCTION__;
   cdm_promise_adapter_->ResolvePromise(promise_id);
 }
@@ skipping 56 matching lines @@
 
   if (media_crypto_ready_cb_.is_null())
     return;
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&MediaDrmBridge::NotifyMediaCryptoReady,
                             weak_factory_.GetWeakPtr(),
                             base::ResetAndReturn(&media_crypto_ready_cb_)));
 }
 
+void MediaDrmBridge::OnStartProvisioning(JNIEnv* env,
+                                         jobject j_media_drm,
+                                         jstring j_default_url,
+                                         jbyteArray j_request_data) {
+  DVLOG(1) << __FUNCTION__;
+
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&MediaDrmBridge::SendProvisioningRequest,
+                                    weak_factory_.GetWeakPtr(),
+                                    ConvertJavaStringToUTF8(env, j_default_url),
+                                    AsString(env, j_request_data)));
+}
+
 void MediaDrmBridge::OnPromiseResolved(JNIEnv* env,
                                        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,
                                                   jobject j_media_drm,
                                                   jint j_promise_id,
                                                   jbyteArray j_session_id) {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&MediaDrmBridge::ResolvePromiseWithSession,
                                     weak_factory_.GetWeakPtr(), j_promise_id,
-                                    GetSessionId(env, j_session_id)));
+                                    AsString(env, j_session_id)));
 }
 
 void MediaDrmBridge::OnPromiseRejected(JNIEnv* env,
                                        jobject j_media_drm,
                                        jint j_promise_id,
                                        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,
                                       jobject j_media_drm,
                                       jbyteArray j_session_id,
                                       jint j_message_type,
                                       jbyteArray j_message,
                                       jstring j_legacy_destination_url) {
   DVLOG(2) << __FUNCTION__;
 
   std::vector<uint8> message;
   JavaByteArrayToByteVector(env, j_message, &message);
   GURL legacy_destination_url =
       GURL(ConvertJavaStringToUTF8(env, j_legacy_destination_url));
   MediaKeys::MessageType message_type =
       GetMessageType(static_cast<RequestType>(j_message_type));
 
   task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(session_message_cb_, GetSessionId(env, j_session_id),
-                 message_type, message, legacy_destination_url));
+      FROM_HERE, base::Bind(session_message_cb_, AsString(env, j_session_id),
+                            message_type, message, legacy_destination_url));
 }
 
 void MediaDrmBridge::OnSessionClosed(JNIEnv* env,
                                      jobject j_media_drm,
                                      jbyteArray j_session_id) {
   DVLOG(2) << __FUNCTION__;
-  std::string session_id = GetSessionId(env, j_session_id);
+  std::string session_id = AsString(env, j_session_id);
   task_runner_->PostTask(FROM_HERE, base::Bind(session_closed_cb_, session_id));
 }
 
 void MediaDrmBridge::OnSessionKeysChange(JNIEnv* env,
                                          jobject j_media_drm,
                                          jbyteArray j_session_id,
                                          jobjectArray j_keys_info,
                                          bool has_additional_usable_key) {
   DVLOG(2) << __FUNCTION__;
 
@@ skipping 21 matching lines @@
 
     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));
   }
 
   task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(session_keys_change_cb_, GetSessionId(env, j_session_id),
+      base::Bind(session_keys_change_cb_, AsString(env, j_session_id),
                  has_additional_usable_key, base::Passed(&cdm_keys_info)));
 }
 
 // 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,
                                                jobject j_media_drm,
                                                jbyteArray j_session_id,
                                                jlong expiry_time_ms) {
   DVLOG(2) << __FUNCTION__ << ": " << expiry_time_ms << " ms";
   session_expiration_update_cb_.Run(
-      GetSessionId(env, j_session_id),
+      AsString(env, j_session_id),
       base::Time::FromDoubleT(expiry_time_ms / 1000.0));
 }
 
 void MediaDrmBridge::OnLegacySessionError(JNIEnv* env,
                                           jobject j_media_drm,
                                           jbyteArray j_session_id,
                                           jstring j_error_message) {
   std::string error_message = ConvertJavaStringToUTF8(env, j_error_message);
 
   DVLOG(2) << __FUNCTION__ << ": " << error_message;
 
   task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(legacy_session_error_cb_, GetSessionId(env, j_session_id),
+      base::Bind(legacy_session_error_cb_, AsString(env, j_session_id),
                  MediaKeys::UNKNOWN_ERROR, 0, error_message));
 }
 
 void MediaDrmBridge::OnResetDeviceCredentialsCompleted(JNIEnv* env,
                                                        jobject,
                                                        bool success) {
-  DVLOG(2) << __FUNCTION__ << ": " << success;
+  DVLOG(2) << __FUNCTION__ << ": success:" << success;
   DCHECK(!reset_credentials_cb_.is_null());
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(base::ResetAndReturn(&reset_credentials_cb_), success));
 }
 
 // The following are private methods.
 
 MediaDrmBridge::MediaDrmBridge(
     const std::vector<uint8>& scheme_uuid,
+    scoped_ptr<ProvisionFetcher> provision_fetcher,
     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),
+      provision_fetcher_(provision_fetcher.Pass()),
       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),
       cdm_promise_adapter_(new CdmPromiseAdapter()),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_factory_(this) {
   DVLOG(1) << __FUNCTION__;
 
+  DCHECK(provision_fetcher_);
+
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
   ScopedJavaLocalRef<jbyteArray> j_scheme_uuid =
       base::android::ToJavaByteArray(env, &scheme_uuid[0], scheme_uuid.size());
   j_media_drm_.Reset(Java_MediaDrmBridge_create(
       env, j_scheme_uuid.obj(), reinterpret_cast<intptr_t>(this)));
 }
 
 MediaDrmBridge::~MediaDrmBridge() {
@@ skipping 33 matching lines @@
   DCHECK(!GetMediaCrypto().is_null());
 
   // We can use scoped_ptr to pass ScopedJavaGlobalRef with a callback.
   scoped_ptr<ScopedJavaGlobalRef<jobject>> j_object_ptr(
       new ScopedJavaGlobalRef<jobject>());
   j_object_ptr->Reset(AttachCurrentThread(), GetMediaCrypto().obj());
 
   cb.Run(j_object_ptr.Pass(), IsProtectedSurfaceRequired());
 }
 
+void MediaDrmBridge::SendProvisioningRequest(const std::string& default_url,
+                                             const std::string& request_data) {
+  DVLOG(1) << __FUNCTION__;
+
+  provision_fetcher_->Retrieve(
+      default_url, request_data,
+      base::Bind(&MediaDrmBridge::ProcessProvisionResponse,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void MediaDrmBridge::ProcessProvisionResponse(bool success,
+                                              const std::string& response) {
+  DVLOG(1) << __FUNCTION__;
+
+  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());
+}
+
 }  // namespace media