Add Promises for EME (Chromium side)

content/renderer/media/crypto/ppapi_decryptor.cc

 // Copyright 2013 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 "content/renderer/media/crypto/ppapi_decryptor.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/renderer/media/crypto/key_systems.h"
 #include "content/renderer/pepper/content_decryptor_delegate.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decoder_buffer.h"
+#include "media/base/media_keys_session_promise.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 
 namespace content {
 
+// This class is need so that resolving an Update() promise triggers playback
+// of the stream.
+class SessionUpdatedPromise : public media::MediaKeysSessionPromise {
+ public:
+  SessionUpdatedPromise(
+      scoped_ptr<media::MediaKeysSessionPromise> caller_promise,
+      media::PromiseResolvedCB resolve_cb);
+  virtual ~SessionUpdatedPromise();
+  virtual void resolve() OVERRIDE;
+  virtual void resolve(const std::string& web_session_id) OVERRIDE;
+  virtual void reject(const std::string& error_name,
+                      uint32 system_code,
+                      const std::string& error_message) OVERRIDE;
+
+ protected:
+  scoped_ptr<media::MediaKeysSessionPromise> caller_promise_;
+  media::PromiseResolvedCB resolve_cb_;
+};
+
+SessionUpdatedPromise::SessionUpdatedPromise(
+    scoped_ptr<media::MediaKeysSessionPromise> caller_promise,
+    media::PromiseResolvedCB resolve_cb)
+    : caller_promise_(caller_promise.Pass()),
+      resolve_cb_(resolve_cb) {
+}
+
+SessionUpdatedPromise::~SessionUpdatedPromise() {
+}
+
+void SessionUpdatedPromise::resolve() {
+  resolve_cb_.Run();
+  caller_promise_->resolve();
+  caller_promise_.reset();
+}
+
+void SessionUpdatedPromise::resolve(const std::string& web_session_id) {
+  NOTREACHED();
+  caller_promise_->resolve(web_session_id);
+  caller_promise_.reset();
+}
+void SessionUpdatedPromise::reject(const std::string& error_name,
+                                   uint32 system_code,
+                                   const std::string& error_message) {
+  caller_promise_->reject(error_name, system_code, error_message);
+  caller_promise_.reset();
+}
+
 scoped_ptr<PpapiDecryptor> PpapiDecryptor::Create(
     const std::string& key_system,
     const GURL& security_origin,
     const CreatePepperCdmCB& create_pepper_cdm_cb,
-    const media::SessionCreatedCB& session_created_cb,
     const media::SessionMessageCB& session_message_cb,
     const media::SessionReadyCB& session_ready_cb,
     const media::SessionClosedCB& session_closed_cb,
     const media::SessionErrorCB& session_error_cb) {
   std::string plugin_type = GetPepperType(key_system);
   DCHECK(!plugin_type.empty());
   scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper =
       create_pepper_cdm_cb.Run(plugin_type, security_origin);
   if (!pepper_cdm_wrapper) {
     DLOG(ERROR) << "Plugin instance creation failed.";
     return scoped_ptr<PpapiDecryptor>();
   }
 
   return scoped_ptr<PpapiDecryptor>(
       new PpapiDecryptor(key_system,
                          pepper_cdm_wrapper.Pass(),
-                         session_created_cb,
                          session_message_cb,
                          session_ready_cb,
                          session_closed_cb,
                          session_error_cb));
 }
 
 PpapiDecryptor::PpapiDecryptor(
     const std::string& key_system,
     scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper,
-    const media::SessionCreatedCB& session_created_cb,
     const media::SessionMessageCB& session_message_cb,
     const media::SessionReadyCB& session_ready_cb,
     const media::SessionClosedCB& session_closed_cb,
     const media::SessionErrorCB& session_error_cb)
     : pepper_cdm_wrapper_(pepper_cdm_wrapper.Pass()),
-      session_created_cb_(session_created_cb),
       session_message_cb_(session_message_cb),
       session_ready_cb_(session_ready_cb),
       session_closed_cb_(session_closed_cb),
       session_error_cb_(session_error_cb),
       render_loop_proxy_(base::MessageLoopProxy::current()),
       weak_ptr_factory_(this) {
   DCHECK(pepper_cdm_wrapper_.get());
-  DCHECK(!session_created_cb_.is_null());
   DCHECK(!session_message_cb_.is_null());
   DCHECK(!session_ready_cb_.is_null());
   DCHECK(!session_closed_cb_.is_null());
   DCHECK(!session_error_cb_.is_null());
 
   base::WeakPtr<PpapiDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr();
   CdmDelegate()->Initialize(
       key_system,
-      base::Bind(&PpapiDecryptor::OnSessionCreated, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionMessage, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionReady, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionClosed, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionError, weak_this),
       base::Bind(&PpapiDecryptor::OnFatalPluginError, weak_this));
 }
 
 PpapiDecryptor::~PpapiDecryptor() {
   pepper_cdm_wrapper_.reset();
 }
 
-bool PpapiDecryptor::CreateSession(uint32 session_id,
-                                   const std::string& content_type,
-                                   const uint8* init_data,
-                                   int init_data_length) {
-  DVLOG(2) << __FUNCTION__;
-  DCHECK(render_loop_proxy_->BelongsToCurrentThread());
-
-  if (!CdmDelegate() ||
-      !CdmDelegate()->CreateSession(
-          session_id, content_type, init_data, init_data_length)) {
-    ReportFailureToCallPlugin(session_id);
-    return false;
-  }
-
-  return true;
-}
-
-void PpapiDecryptor::LoadSession(uint32 session_id,
-                                 const std::string& web_session_id) {
+void PpapiDecryptor::CreateSession(
+    const std::string& init_data_type,
+    const uint8* init_data,
+    int init_data_length,
+    SessionType session_type,
+    scoped_ptr<media::MediaKeysSessionPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
-    ReportFailureToCallPlugin(session_id);
+    promise->reject("InvalidStateError", 0, "CdmDelegate() does not exist.");
+    promise.reset();
     return;
   }
 
-  CdmDelegate()->LoadSession(session_id, web_session_id);
+  CdmDelegate()->CreateSession(init_data_type,
+                               init_data,
+                               init_data_length,
+                               session_type,
+                               promise.Pass());
 }
 
-void PpapiDecryptor::UpdateSession(uint32 session_id,
-                                   const uint8* response,
-                                   int response_length) {
+void PpapiDecryptor::LoadSession(
+    const std::string& web_session_id,
+    scoped_ptr<media::MediaKeysSessionPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
-  if (!CdmDelegate() ||
-      !CdmDelegate()->UpdateSession(session_id, response, response_length)) {
-    ReportFailureToCallPlugin(session_id);
+  if (!CdmDelegate()) {
+    promise->reject("InvalidStateError", 0, "CdmDelegate() does not exist.");
+    promise.reset();
     return;
   }
+
+  CdmDelegate()->LoadSession(web_session_id, promise.Pass());
 }
 
-void PpapiDecryptor::ReleaseSession(uint32 session_id) {
-  DVLOG(2) << __FUNCTION__;
+void PpapiDecryptor::UpdateSession(
+    const std::string& web_session_id,
+    const uint8* response,
+    int response_length,
+    scoped_ptr<media::MediaKeysSessionPromise> promise) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
-  if (!CdmDelegate() || !CdmDelegate()->ReleaseSession(session_id)) {
-    ReportFailureToCallPlugin(session_id);
+  if (!CdmDelegate()) {
+    promise->reject("InvalidStateError", 0, "CdmDelegate() does not exist.");
+    promise.reset();
     return;
   }
+
+  scoped_ptr<SessionUpdatedPromise> update_promise(
+      new SessionUpdatedPromise(promise.Pass(),
+                                base::Bind(&PpapiDecryptor::ResumePlayback,
+                                           weak_ptr_factory_.GetWeakPtr())));
+  CdmDelegate()->UpdateSession(
+      web_session_id,
+      response,
+      response_length,
+      update_promise.PassAs<media::MediaKeysSessionPromise>());
+}
+
+void PpapiDecryptor::ReleaseSession(
+    const std::string& web_session_id,
+    scoped_ptr<media::MediaKeysSessionPromise> promise) {
+  DCHECK(render_loop_proxy_->BelongsToCurrentThread());
+
+  if (!CdmDelegate()) {
+    promise->reject("InvalidStateError", 0, "CdmDelegate() does not exist.");
+    promise.reset();
+    return;
+  }
+
+  CdmDelegate()->ReleaseSession(web_session_id, promise.Pass());
 }
 
 media::Decryptor* PpapiDecryptor::GetDecryptor() {
   return this;
 }
 
 void PpapiDecryptor::RegisterNewKeyCB(StreamType stream_type,
                                       const NewKeyCB& new_key_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
     render_loop_proxy_->PostTask(FROM_HERE,
@@ skipping 170 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(),
                    stream_type));
     return;
   }
 
   DVLOG(2) << __FUNCTION__ << " - stream_type: " << stream_type;
   if (CdmDelegate())
     CdmDelegate()->DeinitializeDecoder(stream_type);
 }
 
-void PpapiDecryptor::ReportFailureToCallPlugin(uint32 session_id) {
-  DCHECK(render_loop_proxy_->BelongsToCurrentThread());
-  DVLOG(1) << "Failed to call plugin.";
-  session_error_cb_.Run(session_id, kUnknownError, 0);
-}
-
 void PpapiDecryptor::OnDecoderInitialized(StreamType stream_type,
                                           bool success) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   switch (stream_type) {
     case kAudio:
       DCHECK(!audio_decoder_init_cb_.is_null());
       base::ResetAndReturn(&audio_decoder_init_cb_).Run(success);
       break;
     case kVideo:
       DCHECK(!video_decoder_init_cb_.is_null());
       base::ResetAndReturn(&video_decoder_init_cb_).Run(success);
       break;
     default:
       NOTREACHED();
   }
 }
 
-void PpapiDecryptor::OnSessionCreated(uint32 session_id,
-                                      const std::string& web_session_id) {
-  DCHECK(render_loop_proxy_->BelongsToCurrentThread());
-  session_created_cb_.Run(session_id, web_session_id);
-}
-
-void PpapiDecryptor::OnSessionMessage(uint32 session_id,
+void PpapiDecryptor::OnSessionMessage(const std::string& web_session_id,
                                       const std::vector<uint8>& message,
                                       const std::string& destination_url) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
-  session_message_cb_.Run(session_id, message, destination_url);
+  session_message_cb_.Run(web_session_id, message, destination_url);
 }
 
-void PpapiDecryptor::OnSessionReady(uint32 session_id) {
+void PpapiDecryptor::OnSessionReady(const std::string& web_session_id) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
+  ResumePlayback();
+  session_ready_cb_.Run(web_session_id);
+}
+
+void PpapiDecryptor::OnSessionClosed(const std::string& web_session_id) {
+  DCHECK(render_loop_proxy_->BelongsToCurrentThread());
+  session_closed_cb_.Run(web_session_id);
+}
+
+void PpapiDecryptor::OnSessionError(const std::string& web_session_id,
+                                    const std::string& error_name,
+                                    uint32 system_code,
+                                    const std::string& error_description) {
+  DCHECK(render_loop_proxy_->BelongsToCurrentThread());
+  session_error_cb_.Run(
+      web_session_id, error_name, system_code, error_description);
+}
+
+void PpapiDecryptor::ResumePlayback() {
   // Based on the spec, we need to resume playback when update() completes
-  // successfully, or when a session is successfully loaded. In both cases,
-  // the CDM fires OnSessionReady() event. So we choose to call the NewKeyCBs
-  // here.
-  // TODO(xhwang): Rename OnSessionReady to indicate that the playback may
-  // resume successfully (e.g. a new key is available or available again).
+  // successfully, or when a session is successfully loaded (triggered by
+  // OnSessionReady()). So we choose to call the NewKeyCBs here.
   if (!new_audio_key_cb_.is_null())
     new_audio_key_cb_.Run();
 
   if (!new_video_key_cb_.is_null())
     new_video_key_cb_.Run();
-
-  session_ready_cb_.Run(session_id);
-}
-
-void PpapiDecryptor::OnSessionClosed(uint32 session_id) {
-  DCHECK(render_loop_proxy_->BelongsToCurrentThread());
-  session_closed_cb_.Run(session_id);
-}
-
-void PpapiDecryptor::OnSessionError(uint32 session_id,
-                                    media::MediaKeys::KeyError error_code,
-                                    uint32 system_code) {
-  DCHECK(render_loop_proxy_->BelongsToCurrentThread());
-  session_error_cb_.Run(session_id, error_code, system_code);
 }
 
 void PpapiDecryptor::OnFatalPluginError() {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   pepper_cdm_wrapper_.reset();
 }
 
 ContentDecryptorDelegate* PpapiDecryptor::CdmDelegate() {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   return (pepper_cdm_wrapper_) ? pepper_cdm_wrapper_->GetCdmDelegate() : NULL;
 }
 
 }  // namespace content