[Clank] Load origin id before create MediaDrmBridge

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 <string>
 #include <utility>
 #include <vector>
@@ skipping 15 matching lines @@
 using base::android::ScopedJavaLocalRef;
 using base::android::ToJavaByteArray;
 
 namespace media {
 
 // static
 bool MediaDrmStorageBridge::RegisterMediaDrmStorageBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
-MediaDrmStorageBridge::MediaDrmStorageBridge(
-    const url::Origin& origin,
-    const CreateStorageCB& create_storage_cb)
-    : create_storage_cb_(create_storage_cb),
-      origin_(origin),
-      task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      weak_factory_(this) {}
+MediaDrmStorageBridge::MediaDrmStorageBridge()
+    : task_runner_(base::ThreadTaskRunnerHandle::Get()), weak_factory_(this) {}
 
 MediaDrmStorageBridge::~MediaDrmStorageBridge() = default;
 
+void MediaDrmStorageBridge::Initialize(const url::Origin& origin,
+                                       const CreateStorageCB& create_storage_cb,
+                                       base::OnceClosure on_init) {
+  DCHECK(create_storage_cb);
+  impl_ = create_storage_cb.Run();
+
+  // TODO(yucliu): MediaDrmStorage should generate and return origin id.
+  impl_->Initialize(origin);

[xhwang, 2017/05/03 06:00:56]

Initalize() should be a method that takes a callback to return an origin ID. The
ID should be generated the first time Initialize() is called, and stored in the
storage. This is because we could have two MediaDrmBridge on the same origin,
calling Initialize() trying to retrieve the origin ID, and the returned ID
should be consistent.

As you have a TODO here, we can do it in the next CL.

[yucliu1, 2017/05/03 06:33:49]

Yes, I mean "return origin id asynchronously in a callback" actually.

+  origin_id_ = origin.Serialize();
+
+  std::move(on_init).Run();
+}
+
 void MediaDrmStorageBridge::OnProvisioned(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_storage,
     // Callback<Boolean>
     const JavaParamRef<jobject>& j_callback) {
+  DCHECK(impl_);
   task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
-          &MediaDrmStorage::OnProvisioned, GetStorageImpl()->AsWeakPtr(),
+          &MediaDrmStorage::OnProvisioned, impl_->AsWeakPtr(),
           base::BindOnce(&MediaDrmStorageBridge::RunAndroidBoolCallback,
                          // Bind callback to WeakPtr in case callback is called
                          // after object is deleted.
                          weak_factory_.GetWeakPtr(),
                          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) {
+  DCHECK(impl_);
   std::string session_id = JavaBytesToString(env, j_session_id);
   task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
-          &MediaDrmStorage::LoadPersistentSession,
-          GetStorageImpl()->AsWeakPtr(), session_id,
+          &MediaDrmStorage::LoadPersistentSession, impl_->AsWeakPtr(),
+          session_id,
           base::BindOnce(&MediaDrmStorageBridge::OnSessionDataLoaded,
                          weak_factory_.GetWeakPtr(),
                          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) {
+  DCHECK(impl_);
   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());
 
   task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
-          &MediaDrmStorage::SavePersistentSession,
-          GetStorageImpl()->AsWeakPtr(), session_id,
+          &MediaDrmStorage::SavePersistentSession, impl_->AsWeakPtr(),
+          session_id,
           MediaDrmStorage::SessionData(std::move(key_set_id), std::move(mime)),
           base::BindOnce(&MediaDrmStorageBridge::RunAndroidBoolCallback,
                          weak_factory_.GetWeakPtr(),
                          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) {
+  DCHECK(impl_);
   task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
-          &MediaDrmStorage::RemovePersistentSession,
-          GetStorageImpl()->AsWeakPtr(), JavaBytesToString(env, j_session_id),
+          &MediaDrmStorage::RemovePersistentSession, impl_->AsWeakPtr(),
+          JavaBytesToString(env, j_session_id),
           base::BindOnce(&MediaDrmStorageBridge::RunAndroidBoolCallback,
                          weak_factory_.GetWeakPtr(),
                          base::Passed(CreateJavaObjectPtr(j_callback.obj())))));
 }
 
 void MediaDrmStorageBridge::RunAndroidBoolCallback(JavaObjectPtr j_callback,
                                                    bool success) {
   RunCallbackAndroid(*j_callback, success);
 }
 
@@ skipping 10 matching lines @@
   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));
 }
 
-MediaDrmStorage* MediaDrmStorageBridge::GetStorageImpl() {
-  if (!impl_) {
-    DCHECK(create_storage_cb_);
-    impl_ = std::move(create_storage_cb_).Run();
-    impl_->Initialize(origin_);
-  }
-
-  return impl_.get();
-}
-
 }  // namespace media