[Clank] Implement MediaDrmStorageBridge with MediaDrmStorage

media/base/android/media_drm_storage_bridge.cc

 // Copyright 2017 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_storage_bridge.h"
 
 #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(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_storage,
     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(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_storage,
     const JavaParamRef<jobject>& j_persist_info,
     // Callback<Boolean>
     const JavaParamRef<jobject>& j_callback) {
-  NOTIMPLEMENTED();
+  std::vector<uint8_t> key_set_id;
+  JavaByteArrayToByteVector(
+      env, Java_PersistentInfo_keySetId(env, j_persist_info.obj()).obj(),
+      &key_set_id);
 
-  RunCallbackAndroid(j_callback, false);
+  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(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_storage,
     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())))));
+}
 
-  RunCallbackAndroid(j_callback, false);
+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)));
+}
+
+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