[Clank] Implement MediaDrmStorageBridge with MediaDrmStorage

media/base/android/media_drm_storage_bridge.cc

Index: media/base/android/media_drm_storage_bridge.cc
diff --git a/media/base/android/media_drm_storage_bridge.cc b/media/base/android/media_drm_storage_bridge.cc
index a9b6047c2c8a980e1346f7ae1f5925c88f979edb..4bc645a9e82437feb05644b496820c08d2c8a9c5 100644
--- a/media/base/android/media_drm_storage_bridge.cc
+++ b/media/base/android/media_drm_storage_bridge.cc
@@ -7,36 +7,73 @@
 #include <memory>
 
 #include "base/android/callback_android.h"
+#include "base/android/jni_array.h"
+#include "base/android/jni_string.h"
+#include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "jni/MediaDrmStorageBridge_jni.h"
+#include "media/base/android/android_util.h"
 
+using base::android::AttachCurrentThread;
+using base::android::ConvertUTF8ToJavaString;
+using base::android::JavaByteArrayToByteVector;
 using base::android::JavaParamRef;
 using base::android::RunCallbackAndroid;
 using base::android::ScopedJavaLocalRef;
+using base::android::ToJavaByteArray;
 
 namespace media {
+namespace {
+void RunAndroidBoolCallback(JavaObjectPtr j_callback, bool success) {
+  RunCallbackAndroid(*j_callback, success);
+}
+
+void OnSessionDataLoaded(
+    JavaObjectPtr j_callback,
+    const std::string& session_id,
+    std::unique_ptr<MediaDrmStorage::SessionData> session_data) {
+  if (!session_data) {
+    RunCallbackAndroid(*j_callback, ScopedJavaLocalRef<jobject>());
+    return;
+  }
+
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jbyteArray> j_eme_id = StringToJavaBytes(env, session_id);
+  ScopedJavaLocalRef<jbyteArray> j_key_set_id = ToJavaByteArray(
+      env, session_data->key_set_id.data(), session_data->key_set_id.size());
+  ScopedJavaLocalRef<jstring> j_mime =
+      ConvertUTF8ToJavaString(env, session_data->mime_type);
+
+  RunCallbackAndroid(*j_callback, Java_PersistentInfo_create(
+                                      env, j_eme_id, j_key_set_id, j_mime));
+}
+}  // namespace
 
 // static
 bool MediaDrmStorageBridge::RegisterMediaDrmStorageBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
-MediaDrmStorageBridge::MediaDrmStorageBridge()
-    : task_runner_(base::ThreadTaskRunnerHandle::Get()), weak_factory_(this) {}
+MediaDrmStorageBridge::MediaDrmStorageBridge(
+    const url::Origin& origin,
+    OnceCreateStorageCB create_storage_cb)
+    : create_storage_cb_(std::move(create_storage_cb)),
+      origin_(origin),
+      task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      weak_factory_(this) {}
 
 MediaDrmStorageBridge::~MediaDrmStorageBridge() = default;
 
-// TODO(yucliu): Implement these methods with MediaDrmStorage
-
 void MediaDrmStorageBridge::OnProvisioned(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_storage,
     // Callback<Boolean>
     const JavaParamRef<jobject>& j_callback) {
-  NOTIMPLEMENTED();
-
-  RunCallbackAndroid(j_callback, true);
+  PostCancellableTask(base::BindOnce(
+      &MediaDrmStorage::OnProvisioned, base::Unretained(GetStorageImpl()),
+      base::BindOnce(&RunAndroidBoolCallback,
+                     base::Passed(CreateJavaObjectPtr(j_callback.obj())))));
 }
 
 void MediaDrmStorageBridge::OnLoadInfo(
@@ -45,9 +82,13 @@ void MediaDrmStorageBridge::OnLoadInfo(
     const JavaParamRef<jbyteArray>& j_session_id,
     // Callback<PersistentInfo>
     const JavaParamRef<jobject>& j_callback) {
-  NOTIMPLEMENTED();
-
-  RunCallbackAndroid(j_callback, ScopedJavaLocalRef<jobject>());
+  std::string session_id = JavaBytesToString(env, j_session_id);
+  PostCancellableTask(base::BindOnce(
+      &MediaDrmStorage::LoadPersistentSession,
+      base::Unretained(GetStorageImpl()), session_id,
+      base::BindOnce(&OnSessionDataLoaded,

[xhwang, 2017/04/07 05:47:35]

Is it safe to call OnSessionDataLoaded() and RunAndroidBoolCallback() after
|this| is destroyed? Imagine the callback is posted into the run loop, then
MediaDrmBridge is destroyed, then the task is run. Is this okay?

[yucliu1, 2017/04/07 18:53:10]

Changed to WeakPtr<MediaDrmStorage>.

[xhwang, 2017/04/07 19:12:52]

Right. But OnSessionDataLoaded() isn't bounded using weakptr, is it okay?

[yucliu1, 2017/04/07 19:30:19]

I think it's safe to do this. If MediaDrmStorage is deleted, it won't call any
of the callbacks passed to it. And these functions don't take pointers to those
objects, so it should be safe to do this. What do you think?

[xhwang, 2017/04/07 21:34:43]

The problem is that OnSessionDataLoaded() is not bound by a weak pointer, and
the bound callback could be posted so it outlives MediaDrmStorage. Either you
need to make sure calling OnSessionDataLoaded() is okay after |this| is
destoryed, or you can make OnSessionDataLoaded a class member method so that you
can use the weakptr of |this| to prevent it from being called after |this| is
destructed.

+                     base::Passed(CreateJavaObjectPtr(j_callback.obj())),
+                     session_id)));
 }
 
 void MediaDrmStorageBridge::OnSaveInfo(
@@ -56,9 +97,23 @@ void MediaDrmStorageBridge::OnSaveInfo(
     const JavaParamRef<jobject>& j_persist_info,
     // Callback<Boolean>
     const JavaParamRef<jobject>& j_callback) {
-  NOTIMPLEMENTED();
-
-  RunCallbackAndroid(j_callback, false);
+  std::vector<uint8_t> key_set_id;
+  JavaByteArrayToByteVector(
+      env, Java_PersistentInfo_keySetId(env, j_persist_info.obj()).obj(),
+      &key_set_id);
+
+  std::string mime = ConvertJavaStringToUTF8(
+      env, Java_PersistentInfo_mimeType(env, j_persist_info.obj()));
+
+  std::string session_id = JavaBytesToString(
+      env, Java_PersistentInfo_emeId(env, j_persist_info.obj()).obj());
+
+  PostCancellableTask(base::BindOnce(
+      &MediaDrmStorage::SavePersistentSession,
+      base::Unretained(GetStorageImpl()), session_id,
+      MediaDrmStorage::SessionData(std::move(key_set_id), std::move(mime)),
+      base::BindOnce(&RunAndroidBoolCallback,
+                     base::Passed(CreateJavaObjectPtr(j_callback.obj())))));
 }
 
 void MediaDrmStorageBridge::OnClearInfo(
@@ -67,8 +122,30 @@ void MediaDrmStorageBridge::OnClearInfo(
     const JavaParamRef<jbyteArray>& j_session_id,
     // Callback<Boolean>
     const JavaParamRef<jobject>& j_callback) {
-  NOTIMPLEMENTED();
+  PostCancellableTask(base::BindOnce(
+      &MediaDrmStorage::RemovePersistentSession,
+      base::Unretained(GetStorageImpl()), JavaBytesToString(env, j_session_id),
+      base::BindOnce(&RunAndroidBoolCallback,
+                     base::Passed(CreateJavaObjectPtr(j_callback.obj())))));
+}
+
+MediaDrmStorage* MediaDrmStorageBridge::GetStorageImpl() {
+  if (!impl_) {
+    DCHECK(!create_storage_cb_.is_null());

[xhwang, 2017/04/07 05:47:35]

nit: DCHECK(create_storage_cb);

[yucliu1, 2017/04/07 18:53:10]

Done.

+    impl_ = std::move(create_storage_cb_).Run();
+    impl_->Initialize(origin_);
+  }
+
+  return impl_.get();
+}
+
+void MediaDrmStorageBridge::PostCancellableTask(base::OnceClosure task) {
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MediaDrmStorageBridge::RunCancellableTask,
+                            weak_factory_.GetWeakPtr(), base::Passed(&task)));
+}
 
-  RunCallbackAndroid(j_callback, false);
+void MediaDrmStorageBridge::RunCancellableTask(base::OnceClosure task) {
+  std::move(task).Run();

[xhwang, 2017/04/07 05:47:35]

What's the purpose of PostCancellableTask and  RunCancellableTask? Is it so that
you can use weak_factory_.GetWeakPtr() so that the callback will be cancelled
when |this| is destructed?

If so, probably add a comment.

Or, maybe we can add a 

virtual base::WeakPtr<MediaDrmStorage> GetWeakPtr() = 0;

in MediaDrmStorage interface. Then you can use it to bind the task. Will that
work for you?

[yucliu1, 2017/04/07 18:53:09]

Add SupportsWeakPtr to MediaDrmStorage, it's redundant for subclass to implement
their own weak ptr. It's the easiest way to get rid of this.

 }
 }  // namespace media