Move MediaDrmBridge provision communication to native side.

media/base/android/media_drm_bridge.cc

Index: media/base/android/media_drm_bridge.cc
diff --git a/media/base/android/media_drm_bridge.cc b/media/base/android/media_drm_bridge.cc
index d453ad921fb1e10bbb68552c69243af9c751d587..35291680b76d8dd610508c287e32077ef244f9dd 100644
--- a/media/base/android/media_drm_bridge.cc
+++ b/media/base/android/media_drm_bridge.cc
@@ -27,6 +27,7 @@
 #include "media/base/android/media_drm_bridge_delegate.h"
 #include "media/base/android/media_task_runner.h"
 #include "media/base/cdm_key_information.h"
+#include "media/base/provision_fetcher.h"
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
@@ -59,11 +60,11 @@ enum class KeyStatus {
   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] = {
@@ -288,6 +289,7 @@ std::vector<std::string> MediaDrmBridge::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,
@@ -303,10 +305,10 @@ ScopedMediaDrmBridgePtr MediaDrmBridge::Create(
   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();
@@ -317,9 +319,15 @@ ScopedMediaDrmBridgePtr MediaDrmBridge::Create(
 // static
 ScopedMediaDrmBridgePtr MediaDrmBridge::CreateWithoutSessionSupport(
     const std::string& key_system) {
-  return MediaDrmBridge::Create(
-      key_system, SessionMessageCB(), SessionClosedCB(), LegacySessionErrorCB(),
-      SessionKeysChangeCB(), SessionExpirationUpdateCB());
+  scoped_ptr<ProvisionFetcher> provision_fetcher =
+      GetMediaClientAndroid()->CreateDefaultFetcher();
+
+  DCHECK(provision_fetcher);
+
+  return MediaDrmBridge::Create(key_system, provision_fetcher.Pass(),
+                                SessionMessageCB(), SessionClosedCB(),
+                                LegacySessionErrorCB(), SessionKeysChangeCB(),
+                                SessionExpirationUpdateCB());
 }
 
 base::WeakPtr<MediaDrmBridge> MediaDrmBridge::WeakPtr() {
@@ -494,6 +502,8 @@ bool MediaDrmBridge::IsProtectedSurfaceRequired() {
 
 void MediaDrmBridge::ResetDeviceCredentials(
     const ResetCredentialsCB& callback) {
+  DVLOG(1) << __FUNCTION__;
+
   DCHECK(reset_credentials_cb_.is_null());
   reset_credentials_cb_ = callback;
   JNIEnv* env = AttachCurrentThread();
@@ -562,6 +572,18 @@ void MediaDrmBridge::OnMediaCryptoReady(JNIEnv* env, jobject j_media_drm) {
                             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) {
@@ -576,7 +598,7 @@ void MediaDrmBridge::OnPromiseResolvedWithSession(JNIEnv* env,
   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,
@@ -605,16 +627,15 @@ void MediaDrmBridge::OnSessionMessage(JNIEnv* env,
       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));
 }
 
@@ -661,7 +682,7 @@ void MediaDrmBridge::OnSessionKeysChange(JNIEnv* env,
 
   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)));
 }
 
@@ -682,7 +703,7 @@ void MediaDrmBridge::OnSessionExpirationUpdate(JNIEnv* env,
                                                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));
 }
 
@@ -696,14 +717,14 @@ void MediaDrmBridge::OnLegacySessionError(JNIEnv* env,
 
   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,
@@ -714,12 +735,14 @@ void MediaDrmBridge::OnResetDeviceCredentialsCompleted(JNIEnv* env,
 
 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),
@@ -786,4 +809,31 @@ void MediaDrmBridge::NotifyMediaCryptoReady(const MediaCryptoReadyCB& cb) {
   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, WeakPtr()));
+}
+
+void MediaDrmBridge::ProcessProvisionResponse(bool success,
+                                              const std::string& response) {
+  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());

[xhwang, 2015/11/06 23:08:19]

static_cast instead of C-style cast.

[Tima Vaisburd, 2015/11/11 03:03:34]

reinterpret_cast, signed and unsigned char seems to be considered unrelated
types.

+
+  Java_MediaDrmBridge_processProvisionResponse(env, j_media_drm_.obj(),
+                                               j_response.obj());
+}
+
 }  // namespace media