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..bb4587145b1aaf5ec6b83005dbeb45e95be9106f 100644
--- a/media/base/android/media_drm_bridge.cc
+++ b/media/base/android/media_drm_bridge.cc
@@ -26,6 +26,8 @@
 #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.
@@ -59,11 +61,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 +290,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 +306,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();
@@ -316,10 +319,12 @@ ScopedMediaDrmBridgePtr MediaDrmBridge::Create(
 
 // 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() {
@@ -494,6 +499,8 @@ bool MediaDrmBridge::IsProtectedSurfaceRequired() {
 
 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();
@@ -562,6 +569,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 +595,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 +624,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 +679,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 +700,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,7 +714,7 @@ 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));
 }
 
@@ -714,12 +732,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 +806,45 @@ 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__ << " 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