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/media_task_runner.h"
+#include "media/base/android/provision_fetcher.h"
+#include "media/base/bind_to_current_loop.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 204 matching lines @@
 }
 
 // static
 std::vector<std::string> MediaDrmBridge::GetPlatformKeySystemNames() {
   return g_key_system_manager.Get().GetPlatformKeySystemNames();
 }
 
 // static
 ScopedMediaDrmBridgePtr 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__;
 
   scoped_ptr<MediaDrmBridge, BrowserCdmDeleter> media_drm_bridge;
   if (!IsAvailable())
     return media_drm_bridge.Pass();
 
   UUID scheme_uuid = g_key_system_manager.Get().GetUUID(key_system);
   if (scheme_uuid.empty())
     return media_drm_bridge.Pass();
 
-  media_drm_bridge.reset(
-      new MediaDrmBridge(scheme_uuid, session_message_cb, session_closed_cb,
-                         legacy_session_error_cb, session_keys_change_cb,
-                         session_expiration_update_cb));
+  media_drm_bridge.reset(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.reset();
 
   return media_drm_bridge.Pass();
 }
 
 // static
 ScopedMediaDrmBridgePtr 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());
 }
 
 base::WeakPtr<MediaDrmBridge> MediaDrmBridge::WeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 void MediaDrmBridge::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
     scoped_ptr<media::SimpleCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
@@ skipping 154 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) << "MediaDrmBridge::" << __FUNCTION__;

[xhwang, 2015/11/02 20:37:05]

nit: In other places we don't use the "MediaDrmBridge" part.

[Tima Vaisburd, 2015/11/05 02:24:07]

Class name removed.

+
   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 48 matching lines @@
   DVLOG(1) << __FUNCTION__;
 
   if (media_crypto_ready_cb_.is_null())
     return;
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&MediaDrmBridge::NotifyMediaCryptoReady, WeakPtr(),
                             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, WeakPtr(),
+                            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,
                                                WeakPtr(), 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, WeakPtr(),
-                 j_promise_id, GetSessionId(env, j_session_id)));
+                 j_promise_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, WeakPtr(), 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 26 matching lines @@
     // TODO(xhwang): Update CdmKeyInformation to take key_id and status in the
     // constructor.
     scoped_ptr<CdmKeyInformation> cdm_key_information(new CdmKeyInformation());
     cdm_key_information->key_id = key_id;
     cdm_key_information->status = key_status;
     cdm_keys_info.push_back(cdm_key_information.release());
   }
 
   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;
   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()),
       use_media_thread_(UseMediaThreadForMediaPlayback()),
       media_weak_factory_(this),
       weak_factory_(this) {
@@ skipping 46 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__ << " default_url:" << default_url;
+
+  provision_fetcher_->Retrieve(

[qinmin, 2015/11/02 19:39:14]

Is it ok to use the UI thread for network request? 
You probably need to use the IO thread,

[Tima Vaisburd, 2015/11/05 02:24:07]

I think URLFetcher::Start() does it by itself:
https://code.google.com/p/chromium/codesearch#chromium/src/net/url_request/ur...

+      default_url, request_data,
+      BindToCurrentLoop(
+          base::Bind(&MediaDrmBridge::ProcessProvisioningResult, WeakPtr())));
+}
+
+void MediaDrmBridge::ProcessProvisioningResult(const std::string& response,

[xhwang, 2015/11/02 20:37:05]

nit: s/ProvisioningResult/ProvisionResponse

[Tima Vaisburd, 2015/11/05 02:24:07]

Done.

+                                               bool success) {
+  DVLOG(1) << __FUNCTION__;
+
+  if (!success) {
+    VLOG(1) << "Device provision failure: can't get server response";
+    return;
+  }
+
+  JNIEnv* env = AttachCurrentThread();
+
+  ScopedJavaLocalRef<jbyteArray> j_response = base::android::ToJavaByteArray(
+      env, (uint8_t*)response.data(), response.size());
+
+  bool is_response_accepted = Java_MediaDrmBridge_provideProvisionResponse(
+      env, j_media_drm_.obj(), j_response.obj());
+
+  DVLOG(1) << __FUNCTION__ << ": provideProvisionResponse returned "
+           << is_response_accepted;
+
+  if (!reset_credentials_cb_.is_null()) {

[xhwang, 2015/11/02 20:37:05]

We can also fire reset_credentials_cb_ in OnResetDeviceCredentialsCompleted().
IMHO, having multiple ways to do one thing makes the code complicated.

Can we keep ProcessProvisioningResult() simple by just providing the response to
the Java code, then Java code can decide whether to call 
OnResetDeviceCredentialsCompleted(), and/or process pending create session data
(below)?

[Tima Vaisburd, 2015/11/05 02:24:07]

Done.

+    base::ResetAndReturn(&reset_credentials_cb_).Run(is_response_accepted);
+    return;
+  }
+
+  if (is_response_accepted) {
+    Java_MediaDrmBridge_processPendingCreateSessionData(env,
+                                                        j_media_drm_.obj());
+  }
+}
+
 }  // namespace media