Add Promises for EME (Chromium side)

content/renderer/pepper/content_decryptor_delegate.cc

 // Copyright (c) 2012 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/pepper/content_decryptor_delegate.h"
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_conversions.h"
 #include "content/renderer/pepper/ppb_buffer_impl.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/base/cdm_promise.h"
 #include "media/base/channel_layout.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
@@ skipping 213 matching lines @@
     case PP_DECRYPTEDSAMPLEFORMAT_PLANAR_S16:
       return media::kSampleFormatPlanarS16;
     case PP_DECRYPTEDSAMPLEFORMAT_PLANAR_F32:
       return media::kSampleFormatPlanarF32;
     default:
       NOTREACHED();
       return media::kUnknownSampleFormat;
   }
 }
 
+PP_SessionType MediaSessionTypeToPpSessionType(
+    media::MediaKeys::SessionType session_type) {
+  switch (session_type) {
+    case media::MediaKeys::SESSION_TYPE_TEMPORARY:
+      return PP_SESSIONTYPE_TEMPORARY;
+    case media::MediaKeys::SESSION_TYPE_PERSISTENT:
+      return PP_SESSIONTYPE_PERSISTENT;
+    default:
+      NOTREACHED();
+      return PP_SESSIONTYPE_TEMPORARY;
+  }
+}
+
+media::MediaKeys::MediaKeysException PpExceptionTypeToMediaException(
+    PP_ExceptionCodeType exception_code) {
+  switch (exception_code) {
+    case PP_EXCEPTIONCODETYPE_INDEXSIZEERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_INDEX_SIZE_ERROR;
+    case PP_EXCEPTIONCODETYPE_HIERARCHYREQUESTERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_HIERARCHY_REQUEST_ERROR;
+    case PP_EXCEPTIONCODETYPE_WRONGDOCUMENTERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_WRONG_DOCUMENT_ERROR;
+    case PP_EXCEPTIONCODETYPE_INVALIDCHARACTERERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_INVALID_CHARACTER_ERROR;
+    case PP_EXCEPTIONCODETYPE_NOMODIFICATIONALLOWEDERROR:
+      return media::MediaKeys::
+          MEDIA_KEYS_EXCEPTION_NO_MODIFICATION_ALLOWED_ERROR;
+    case PP_EXCEPTIONCODETYPE_NOTFOUNDERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_NOT_FOUND_ERROR;
+    case PP_EXCEPTIONCODETYPE_NOTSUPPORTEDERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_NOT_SUPPORTED_ERROR;
+    case PP_EXCEPTIONCODETYPE_INVALIDSTATEERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_INVALID_STATE_ERROR;
+    case PP_EXCEPTIONCODETYPE_SYNTAXERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_SYNTAX_ERROR;
+    case PP_EXCEPTIONCODETYPE_INVALIDMODIFICATIONERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_INVALID_MODIFICATION_ERROR;
+    case PP_EXCEPTIONCODETYPE_NAMESPACEERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_NAMESPACE_ERROR;
+    case PP_EXCEPTIONCODETYPE_INVALIDACCESSERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_INVALID_ACCESS_ERROR;
+    case PP_EXCEPTIONCODETYPE_SECURITYERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_SECURITY_ERROR;
+    case PP_EXCEPTIONCODETYPE_NETWORKERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_NETWORK_ERROR;
+    case PP_EXCEPTIONCODETYPE_ABORTERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_ABORT_ERROR;
+    case PP_EXCEPTIONCODETYPE_URLMISMATCHERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_URL_MISMATCH_ERROR;
+    case PP_EXCEPTIONCODETYPE_QUOTAEXCEEDEDERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_QUOTA_EXCEEDED_ERROR;
+    case PP_EXCEPTIONCODETYPE_TIMEOUTERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_TIMEOUT_ERROR;
+    case PP_EXCEPTIONCODETYPE_INVALIDNODETYPEERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_INVALID_NODE_TYPE_ERROR;
+    case PP_EXCEPTIONCODETYPE_DATACLONEERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_DATA_CLONE_ERROR;
+    case PP_EXCEPTIONCODETYPE_ENCODINGERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_ENCODING_ERROR;
+    case PP_EXCEPTIONCODETYPE_NOTREADABLEERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_NOT_READABLE_ERROR;
+    case PP_EXCEPTIONCODETYPE_DATAERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_DATA_ERROR;
+    case PP_EXCEPTIONCODETYPE_OPERATIONERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_OPERATION_ERROR;
+    case PP_EXCEPTIONCODETYPE_VERSIONERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_VERSION_ERROR;
+    case PP_EXCEPTIONCODETYPE_UNKNOWNERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_UNKNOWN_ERROR;
+    case PP_EXCEPTIONCODETYPE_CLIENTERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_CLIENT_ERROR;
+    case PP_EXCEPTIONCODETYPE_OUTPUTERROR:
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_OUTPUT_ERROR;
+    default:
+      NOTREACHED();
+      return media::MediaKeys::MEDIA_KEYS_EXCEPTION_SECURITY_ERROR;
+  }
+}
+
 }  // namespace
 
 ContentDecryptorDelegate::ContentDecryptorDelegate(
     PP_Instance pp_instance,
     const PPP_ContentDecryptor_Private* plugin_decryption_interface)
     : pp_instance_(pp_instance),
       plugin_decryption_interface_(plugin_decryption_interface),
       next_decryption_request_id_(1),
       audio_samples_per_second_(0),
       audio_channel_count_(0),
       audio_channel_layout_(media::CHANNEL_LAYOUT_NONE),
+      next_promise_id_(0),
       weak_ptr_factory_(this) {
   weak_this_ = weak_ptr_factory_.GetWeakPtr();
 }
 
 ContentDecryptorDelegate::~ContentDecryptorDelegate() {
   SatisfyAllPendingCallbacksOnError();
 }
 
 void ContentDecryptorDelegate::Initialize(
     const std::string& key_system,
-    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,
     const base::Closure& fatal_plugin_error_cb) {
   DCHECK(!key_system.empty());
   DCHECK(key_system_.empty());
   key_system_ = key_system;
 
-  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;
   fatal_plugin_error_cb_ = fatal_plugin_error_cb;
 
   plugin_decryption_interface_->Initialize(
       pp_instance_, StringVar::StringToPPVar(key_system_));
 }
 
 void ContentDecryptorDelegate::InstanceCrashed() {
   fatal_plugin_error_cb_.Run();
   SatisfyAllPendingCallbacksOnError();
 }
 
-bool ContentDecryptorDelegate::CreateSession(uint32 session_id,
-                                             const std::string& content_type,
-                                             const uint8* init_data,
-                                             int init_data_length) {
+void ContentDecryptorDelegate::CreateSession(
+    const std::string& init_data_type,
+    const uint8* init_data,
+    int init_data_length,
+    media::MediaKeys::SessionType session_type,
+    scoped_ptr<media::CdmPromise<std::string> > promise) {
+  uint32_t promise_id = SaveSessionPromise(promise.Pass());
   PP_Var init_data_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           init_data_length, init_data);
-
   plugin_decryption_interface_->CreateSession(
       pp_instance_,
-      session_id,
-      StringVar::StringToPPVar(content_type),
-      init_data_array);
-  return true;
+      promise_id,
+      StringVar::StringToPPVar(init_data_type),
+      init_data_array,
+      MediaSessionTypeToPpSessionType(session_type));
 }
 
-void ContentDecryptorDelegate::LoadSession(uint32 session_id,
-                                           const std::string& web_session_id) {
+void ContentDecryptorDelegate::LoadSession(
+    const std::string& web_session_id,
+    scoped_ptr<media::CdmPromise<std::string> > promise) {
+  uint32_t promise_id = SaveSessionPromise(promise.Pass());
   plugin_decryption_interface_->LoadSession(
-      pp_instance_, session_id, StringVar::StringToPPVar(web_session_id));
+      pp_instance_, promise_id, StringVar::StringToPPVar(web_session_id));
 }
 
-bool ContentDecryptorDelegate::UpdateSession(uint32 session_id,
-                                             const uint8* response,
-                                             int response_length) {
+void ContentDecryptorDelegate::UpdateSession(
+    const std::string& web_session_id,
+    const uint8* response,
+    int response_length,
+    scoped_ptr<media::CdmPromise<void> > promise) {
+  uint32_t promise_id = SaveVoidPromise(promise.Pass());
   PP_Var response_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           response_length, response);
   plugin_decryption_interface_->UpdateSession(
-      pp_instance_, session_id, response_array);
-  return true;
+      pp_instance_,
+      promise_id,
+      StringVar::StringToPPVar(web_session_id),
+      response_array);
 }
 
-bool ContentDecryptorDelegate::ReleaseSession(uint32 session_id) {
-  plugin_decryption_interface_->ReleaseSession(pp_instance_, session_id);
-  return true;
+void ContentDecryptorDelegate::ReleaseSession(
+    const std::string& web_session_id,
+    scoped_ptr<media::CdmPromise<void> > promise) {
+  uint32_t promise_id = SaveVoidPromise(promise.Pass());
+  plugin_decryption_interface_->ReleaseSession(
+      pp_instance_, promise_id, StringVar::StringToPPVar(web_session_id));
 }
 
 // TODO(xhwang): Remove duplication of code in Decrypt(),
 // DecryptAndDecodeAudio() and DecryptAndDecodeVideo().
 bool ContentDecryptorDelegate::Decrypt(
     Decryptor::StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const Decryptor::DecryptCB& decrypt_cb) {
   DVLOG(3) << "Decrypt() - stream_type: " << stream_type;
 
@@ skipping 225 matching lines @@
   // buffer.
   video_decode_cb_.Set(request_id, video_decode_cb);
 
   // TODO(tomfinegan): Need to get stream type from media stack.
   ScopedPPResource pp_resource(encrypted_resource.get());
   plugin_decryption_interface_->DecryptAndDecode(
       pp_instance_, PP_DECRYPTORSTREAMTYPE_VIDEO, pp_resource, &block_info);
   return true;
 }
 
-void ContentDecryptorDelegate::OnSessionCreated(uint32 session_id,
-                                                PP_Var web_session_id_var) {
-  if (session_created_cb_.is_null())
-    return;
-
-  StringVar* session_id_string = StringVar::FromPPVar(web_session_id_var);
-
-  if (!session_id_string) {
-    OnSessionError(session_id, media::MediaKeys::kUnknownError, 0);
-    return;
-  }
-
-  session_created_cb_.Run(session_id, session_id_string->value());
+void ContentDecryptorDelegate::OnPromiseResolved(uint32 promise_id) {
+  scoped_ptr<media::CdmPromise<void> > promise =
+      RetrieveVoidPromise(promise_id);
+  promise->resolve();
 }
 
-void ContentDecryptorDelegate::OnSessionMessage(uint32 session_id,
+void ContentDecryptorDelegate::OnPromiseResolvedWithSession(
+    uint32 promise_id,
+    PP_Var web_session_id_var) {
+  scoped_ptr<media::CdmPromise<std::string> > promise =
+      RetrieveSessionPromise(promise_id);
+
+  StringVar* web_session_id = StringVar::FromPPVar(web_session_id_var);
+  DCHECK(web_session_id);
+
+  promise->resolve(web_session_id->value());
+}
+
+void ContentDecryptorDelegate::OnPromiseRejected(
+    uint32 promise_id,
+    PP_ExceptionCodeType exception_code,
+    uint32 system_code,
+    PP_Var error_description_var) {
+  StringVar* error_description = StringVar::FromPPVar(error_description_var);
+  DCHECK(error_description);
+
+  scoped_ptr<media::CdmPromise<std::string> > promise =
+      RetrieveSessionPromise(promise_id);
+  if (promise) {
+    promise->reject(PpExceptionTypeToMediaException(exception_code),
+                    system_code,
+                    error_description->value());
+  } else {
+    scoped_ptr<media::CdmPromise<void> > promise =
+        RetrieveVoidPromise(promise_id);
+    promise->reject(PpExceptionTypeToMediaException(exception_code),
+                    system_code,
+                    error_description->value());
+  }
+}
+
+void ContentDecryptorDelegate::OnSessionMessage(PP_Var web_session_id_var,
                                                 PP_Var message_var,
-                                                PP_Var default_url_var) {
+                                                PP_Var destination_url_var) {
   if (session_message_cb_.is_null())
     return;
 
+  StringVar* web_session_id = StringVar::FromPPVar(web_session_id_var);
+  DCHECK(web_session_id);
+
   ArrayBufferVar* message_array_buffer = ArrayBufferVar::FromPPVar(message_var);
-
   std::vector<uint8> message;
   if (message_array_buffer) {
     const uint8* data = static_cast<const uint8*>(message_array_buffer->Map());
     message.assign(data, data + message_array_buffer->ByteLength());
   }
 
-  StringVar* default_url_string = StringVar::FromPPVar(default_url_var);
+  StringVar* destination_url_string = StringVar::FromPPVar(destination_url_var);
+  DCHECK(destination_url_string);
 
-  if (!default_url_string) {
-    OnSessionError(session_id, media::MediaKeys::kUnknownError, 0);
-    return;
-  }
-
-  session_message_cb_.Run(session_id, message, default_url_string->value());
+  session_message_cb_.Run(
+      web_session_id->value(), message, destination_url_string->value());
 }
 
-void ContentDecryptorDelegate::OnSessionReady(uint32 session_id) {
+void ContentDecryptorDelegate::OnSessionReady(PP_Var web_session_id_var) {
   if (session_ready_cb_.is_null())
     return;
 
-  session_ready_cb_.Run(session_id);
+  StringVar* web_session_id = StringVar::FromPPVar(web_session_id_var);
+  DCHECK(web_session_id);
+
+  session_ready_cb_.Run(web_session_id->value());
 }
 
-void ContentDecryptorDelegate::OnSessionClosed(uint32 session_id) {
+void ContentDecryptorDelegate::OnSessionClosed(PP_Var web_session_id_var) {
   if (session_closed_cb_.is_null())
     return;
 
-  session_closed_cb_.Run(session_id);
+  StringVar* web_session_id = StringVar::FromPPVar(web_session_id_var);
+  DCHECK(web_session_id);
+
+  session_closed_cb_.Run(web_session_id->value());
 }
 
-void ContentDecryptorDelegate::OnSessionError(uint32 session_id,
-                                              int32_t media_error,
-                                              uint32_t system_code) {
+void ContentDecryptorDelegate::OnSessionError(
+    PP_Var web_session_id_var,
+    PP_ExceptionCodeType exception_code,
+    uint32 system_code,
+    PP_Var error_description_var) {
   if (session_error_cb_.is_null())
     return;
 
-  session_error_cb_.Run(session_id,
-                        static_cast<media::MediaKeys::KeyError>(media_error),
-                        system_code);
+  StringVar* web_session_id = StringVar::FromPPVar(web_session_id_var);
+  DCHECK(web_session_id);
+
+  StringVar* error_description = StringVar::FromPPVar(error_description_var);
+  DCHECK(error_description);
+
+  session_error_cb_.Run(web_session_id->value(),
+                        PpExceptionTypeToMediaException(exception_code),
+                        system_code,
+                        error_description->value());
 }
 
 void ContentDecryptorDelegate::DecoderInitializeDone(
     PP_DecryptorStreamType decoder_type,
     uint32_t request_id,
     PP_Bool success) {
   if (decoder_type == PP_DECRYPTORSTREAMTYPE_AUDIO) {
     // If the request ID is not valid or does not match what's saved, do
     // nothing.
     if (request_id == 0 || !audio_decoder_init_cb_.Matches(request_id))
@@ skipping 383 matching lines @@
                                           frame_count));
     frames->push_back(frame);
 
     cur += frame_size;
     bytes_left -= frame_size;
   } while (bytes_left > 0);
 
   return true;
 }
 
 void ContentDecryptorDelegate::SatisfyAllPendingCallbacksOnError() {

[jrummell, 2014/05/08 23:37:46]

Need to reject any pending promises here.

[jrummell, 2014/05/09 00:55:23]

Done.

   if (!audio_decoder_init_cb_.is_null())
     audio_decoder_init_cb_.ResetAndReturn().Run(false);
 
   if (!video_decoder_init_cb_.is_null())
     video_decoder_init_cb_.ResetAndReturn().Run(false);
 
   audio_input_resource_ = NULL;
   video_input_resource_ = NULL;
 
   if (!audio_decrypt_cb_.is_null())
     audio_decrypt_cb_.ResetAndReturn().Run(media::Decryptor::kError, NULL);
 
   if (!video_decrypt_cb_.is_null())
     video_decrypt_cb_.ResetAndReturn().Run(media::Decryptor::kError, NULL);
 
   if (!audio_decode_cb_.is_null()) {
     const media::Decryptor::AudioBuffers empty_frames;
     audio_decode_cb_.ResetAndReturn().Run(media::Decryptor::kError,
                                           empty_frames);
   }
 
   if (!video_decode_cb_.is_null())
     video_decode_cb_.ResetAndReturn().Run(media::Decryptor::kError, NULL);
 }
 
+uint32_t ContentDecryptorDelegate::SaveVoidPromise(
+    scoped_ptr<media::CdmPromise<void> > promise) {
+  uint32_t promise_id = ++next_promise_id_;
+  void_promises_.insert(std::make_pair(promise_id, promise.release()));
+  return promise_id;
+}
+
+scoped_ptr<media::CdmPromise<void> >
+ContentDecryptorDelegate::RetrieveVoidPromise(uint32_t promise_id) {
+  std::map<uint32_t, media::CdmPromise<void>*>::iterator it =
+      void_promises_.find(promise_id);
+  if (it == void_promises_.end())
+    return scoped_ptr<media::CdmPromise<void> >();
+  scoped_ptr<media::CdmPromise<void> > result(it->second);
+  void_promises_.erase(it);
+  return result.Pass();
+}
+
+uint32_t ContentDecryptorDelegate::SaveSessionPromise(
+    scoped_ptr<media::CdmPromise<std::string> > promise) {
+  uint32_t promise_id = ++next_promise_id_;
+  session_promises_.insert(std::make_pair(promise_id, promise.release()));
+  return promise_id;
+}
+
+scoped_ptr<media::CdmPromise<std::string> >
+ContentDecryptorDelegate::RetrieveSessionPromise(uint32_t promise_id) {
+  std::map<uint32_t, media::CdmPromise<std::string>*>::iterator it =
+      session_promises_.find(promise_id);
+  if (it == session_promises_.end())
+    return scoped_ptr<media::CdmPromise<std::string> >();
+  scoped_ptr<media::CdmPromise<std::string> > result(it->second);
+  session_promises_.erase(it);
+  return result.Pass();
+}
+
 }  // namespace content