Home | History | Annotate | Download | only in crypto 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/renderer/media/crypto/ppapi_decryptor.h"
      6 
      7 #include <string>
      8 
      9 #include "base/bind.h"
     10 #include "base/callback.h"
     11 #include "base/callback_helpers.h"
     12 #include "base/location.h"
     13 #include "base/logging.h"
     14 #include "base/message_loop/message_loop.h"
     15 #include "base/message_loop/message_loop_proxy.h"
     16 #include "content/renderer/media/crypto/key_systems.h"
     17 #include "content/renderer/pepper/content_decryptor_delegate.h"
     18 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
     19 #include "media/base/audio_decoder_config.h"
     20 #include "media/base/cdm_promise.h"
     21 #include "media/base/data_buffer.h"
     22 #include "media/base/decoder_buffer.h"
     23 #include "media/base/video_decoder_config.h"
     24 #include "media/base/video_frame.h"
     25 
     26 namespace content {
     27 
     28 // This class is needed so that resolving an Update() promise triggers playback
     29 // of the stream. It intercepts the resolve() call to invoke an additional
     30 // callback.
     31 class SessionUpdatedPromise : public media::SimpleCdmPromise {
     32  public:
     33   SessionUpdatedPromise(scoped_ptr<media::SimpleCdmPromise> caller_promise,
     34                         base::Closure additional_resolve_cb)
     35       : caller_promise_(caller_promise.Pass()),
     36         additional_resolve_cb_(additional_resolve_cb) {}
     37 
     38   virtual void resolve() OVERRIDE {
     39     DCHECK(is_pending_);
     40     is_pending_ = false;
     41     additional_resolve_cb_.Run();
     42     caller_promise_->resolve();
     43   }
     44 
     45   virtual void reject(media::MediaKeys::Exception exception_code,
     46                       uint32 system_code,
     47                       const std::string& error_message) OVERRIDE {
     48     DCHECK(is_pending_);
     49     is_pending_ = false;
     50     caller_promise_->reject(exception_code, system_code, error_message);
     51   }
     52 
     53  protected:
     54   scoped_ptr<media::SimpleCdmPromise> caller_promise_;
     55   base::Closure additional_resolve_cb_;
     56 };
     57 
     58 // This class is needed so that resolving a SessionLoaded() promise triggers
     59 // playback of the stream. It intercepts the resolve() call to invoke an
     60 // additional callback. This is only needed until KeysChange event gets passed
     61 // through Pepper.
     62 class SessionLoadedPromise : public media::NewSessionCdmPromise {
     63  public:
     64   SessionLoadedPromise(scoped_ptr<media::NewSessionCdmPromise> caller_promise,
     65                        base::Closure additional_resolve_cb)
     66       : caller_promise_(caller_promise.Pass()),
     67         additional_resolve_cb_(additional_resolve_cb) {}
     68 
     69   virtual void resolve(const std::string& web_session_id) OVERRIDE {
     70     DCHECK(is_pending_);
     71     is_pending_ = false;
     72     additional_resolve_cb_.Run();
     73     caller_promise_->resolve(web_session_id);
     74   }
     75 
     76   virtual void reject(media::MediaKeys::Exception exception_code,
     77                       uint32 system_code,
     78                       const std::string& error_message) OVERRIDE {
     79     DCHECK(is_pending_);
     80     is_pending_ = false;
     81     caller_promise_->reject(exception_code, system_code, error_message);
     82   }
     83 
     84  protected:
     85   scoped_ptr<media::NewSessionCdmPromise> caller_promise_;
     86   base::Closure additional_resolve_cb_;
     87 };
     88 
     89 scoped_ptr<PpapiDecryptor> PpapiDecryptor::Create(
     90     const std::string& key_system,
     91     const GURL& security_origin,
     92     const CreatePepperCdmCB& create_pepper_cdm_cb,
     93     const media::SessionMessageCB& session_message_cb,
     94     const media::SessionReadyCB& session_ready_cb,
     95     const media::SessionClosedCB& session_closed_cb,
     96     const media::SessionErrorCB& session_error_cb,
     97     const media::SessionKeysChangeCB& session_keys_change_cb,
     98     const media::SessionExpirationUpdateCB& session_expiration_update_cb) {
     99   std::string plugin_type = GetPepperType(key_system);
    100   DCHECK(!plugin_type.empty());
    101   scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper =
    102       create_pepper_cdm_cb.Run(plugin_type, security_origin);
    103   if (!pepper_cdm_wrapper) {
    104     DLOG(ERROR) << "Plugin instance creation failed.";
    105     return scoped_ptr<PpapiDecryptor>();
    106   }
    107 
    108   return scoped_ptr<PpapiDecryptor>(
    109       new PpapiDecryptor(key_system,
    110                          pepper_cdm_wrapper.Pass(),
    111                          session_message_cb,
    112                          session_ready_cb,
    113                          session_closed_cb,
    114                          session_error_cb,
    115                          session_keys_change_cb,
    116                          session_expiration_update_cb));
    117 }
    118 
    119 PpapiDecryptor::PpapiDecryptor(
    120     const std::string& key_system,
    121     scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper,
    122     const media::SessionMessageCB& session_message_cb,
    123     const media::SessionReadyCB& session_ready_cb,
    124     const media::SessionClosedCB& session_closed_cb,
    125     const media::SessionErrorCB& session_error_cb,
    126     const media::SessionKeysChangeCB& session_keys_change_cb,
    127     const media::SessionExpirationUpdateCB& session_expiration_update_cb)
    128     : pepper_cdm_wrapper_(pepper_cdm_wrapper.Pass()),
    129       session_message_cb_(session_message_cb),
    130       session_ready_cb_(session_ready_cb),
    131       session_closed_cb_(session_closed_cb),
    132       session_error_cb_(session_error_cb),
    133       session_keys_change_cb_(session_keys_change_cb),
    134       session_expiration_update_cb_(session_expiration_update_cb),
    135       render_loop_proxy_(base::MessageLoopProxy::current()),
    136       weak_ptr_factory_(this) {
    137   DCHECK(pepper_cdm_wrapper_.get());
    138   DCHECK(!session_message_cb_.is_null());
    139   DCHECK(!session_ready_cb_.is_null());
    140   DCHECK(!session_closed_cb_.is_null());
    141   DCHECK(!session_error_cb_.is_null());
    142   DCHECK(!session_keys_change_cb.is_null());
    143   DCHECK(!session_expiration_update_cb.is_null());
    144 
    145   base::WeakPtr<PpapiDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr();
    146   CdmDelegate()->Initialize(
    147       key_system,
    148       base::Bind(&PpapiDecryptor::OnSessionMessage, weak_this),
    149       base::Bind(&PpapiDecryptor::OnSessionReady, weak_this),
    150       base::Bind(&PpapiDecryptor::OnSessionClosed, weak_this),
    151       base::Bind(&PpapiDecryptor::OnSessionError, weak_this),
    152       base::Bind(&PpapiDecryptor::OnSessionKeysChange, weak_this),
    153       base::Bind(&PpapiDecryptor::OnSessionExpirationUpdate, weak_this),
    154       base::Bind(&PpapiDecryptor::OnFatalPluginError, weak_this));
    155 }
    156 
    157 PpapiDecryptor::~PpapiDecryptor() {
    158   pepper_cdm_wrapper_.reset();
    159 }
    160 
    161 void PpapiDecryptor::SetServerCertificate(
    162     const uint8* certificate_data,
    163     int certificate_data_length,
    164     scoped_ptr<media::SimpleCdmPromise> promise) {
    165   DVLOG(2) << __FUNCTION__;
    166   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    167 
    168   if (!CdmDelegate()) {
    169     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
    170     return;
    171   }
    172 
    173   CdmDelegate()->SetServerCertificate(
    174       certificate_data, certificate_data_length, promise.Pass());
    175 }
    176 
    177 void PpapiDecryptor::CreateSession(
    178     const std::string& init_data_type,
    179     const uint8* init_data,
    180     int init_data_length,
    181     SessionType session_type,
    182     scoped_ptr<media::NewSessionCdmPromise> promise) {
    183   DVLOG(2) << __FUNCTION__;
    184   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    185 
    186   if (!CdmDelegate()) {
    187     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
    188     return;
    189   }
    190 
    191   CdmDelegate()->CreateSession(init_data_type,
    192                                init_data,
    193                                init_data_length,
    194                                session_type,
    195                                promise.Pass());
    196 }
    197 
    198 void PpapiDecryptor::LoadSession(
    199     const std::string& web_session_id,
    200     scoped_ptr<media::NewSessionCdmPromise> promise) {
    201   DVLOG(2) << __FUNCTION__;
    202   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    203 
    204   if (!CdmDelegate()) {
    205     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
    206     return;
    207   }
    208 
    209   // TODO(jrummell): Intercepting the promise should not be necessary once
    210   // OnSessionKeysChange() is called in all cases. http://crbug.com/413413.
    211   scoped_ptr<SessionLoadedPromise> session_loaded_promise(
    212       new SessionLoadedPromise(promise.Pass(),
    213                                base::Bind(&PpapiDecryptor::ResumePlayback,
    214                                           weak_ptr_factory_.GetWeakPtr())));
    215 
    216   CdmDelegate()->LoadSession(
    217       web_session_id,
    218       session_loaded_promise.PassAs<media::NewSessionCdmPromise>());
    219 }
    220 
    221 void PpapiDecryptor::UpdateSession(
    222     const std::string& web_session_id,
    223     const uint8* response,
    224     int response_length,
    225     scoped_ptr<media::SimpleCdmPromise> promise) {
    226   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    227 
    228   if (!CdmDelegate()) {
    229     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
    230     return;
    231   }
    232 
    233   // TODO(jrummell): Intercepting the promise should not be necessary once
    234   // OnSessionKeysChange() is called in all cases. http://crbug.com/413413.
    235   scoped_ptr<SessionUpdatedPromise> session_updated_promise(
    236       new SessionUpdatedPromise(promise.Pass(),
    237                                 base::Bind(&PpapiDecryptor::ResumePlayback,
    238                                            weak_ptr_factory_.GetWeakPtr())));
    239   CdmDelegate()->UpdateSession(
    240       web_session_id,
    241       response,
    242       response_length,
    243       session_updated_promise.PassAs<media::SimpleCdmPromise>());
    244 }
    245 
    246 void PpapiDecryptor::CloseSession(const std::string& web_session_id,
    247                                   scoped_ptr<media::SimpleCdmPromise> promise) {
    248   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    249 
    250   if (!CdmDelegate()) {
    251     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
    252     return;
    253   }
    254 
    255   CdmDelegate()->CloseSession(web_session_id, promise.Pass());
    256 }
    257 
    258 void PpapiDecryptor::RemoveSession(
    259     const std::string& web_session_id,
    260     scoped_ptr<media::SimpleCdmPromise> promise) {
    261   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    262 
    263   if (!CdmDelegate()) {
    264     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
    265     return;
    266   }
    267 
    268   CdmDelegate()->RemoveSession(web_session_id, promise.Pass());
    269 }
    270 
    271 void PpapiDecryptor::GetUsableKeyIds(const std::string& web_session_id,
    272                                      scoped_ptr<media::KeyIdsPromise> promise) {
    273   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    274 
    275   if (!CdmDelegate()) {
    276     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
    277     return;
    278   }
    279 
    280   CdmDelegate()->GetUsableKeyIds(web_session_id, promise.Pass());
    281 }
    282 
    283 media::Decryptor* PpapiDecryptor::GetDecryptor() {
    284   return this;
    285 }
    286 
    287 void PpapiDecryptor::RegisterNewKeyCB(StreamType stream_type,
    288                                       const NewKeyCB& new_key_cb) {
    289   if (!render_loop_proxy_->BelongsToCurrentThread()) {
    290     render_loop_proxy_->PostTask(FROM_HERE,
    291                                  base::Bind(&PpapiDecryptor::RegisterNewKeyCB,
    292                                             weak_ptr_factory_.GetWeakPtr(),
    293                                             stream_type,
    294                                             new_key_cb));
    295     return;
    296   }
    297 
    298   DVLOG(3) << __FUNCTION__ << " - stream_type: " << stream_type;
    299   switch (stream_type) {
    300     case kAudio:
    301       new_audio_key_cb_ = new_key_cb;
    302       break;
    303     case kVideo:
    304       new_video_key_cb_ = new_key_cb;
    305       break;
    306     default:
    307       NOTREACHED();
    308   }
    309 }
    310 
    311 void PpapiDecryptor::Decrypt(
    312     StreamType stream_type,
    313     const scoped_refptr<media::DecoderBuffer>& encrypted,
    314     const DecryptCB& decrypt_cb) {
    315   if (!render_loop_proxy_->BelongsToCurrentThread()) {
    316     render_loop_proxy_->PostTask(FROM_HERE,
    317                                  base::Bind(&PpapiDecryptor::Decrypt,
    318                                             weak_ptr_factory_.GetWeakPtr(),
    319                                             stream_type,
    320                                             encrypted,
    321                                             decrypt_cb));
    322     return;
    323   }
    324 
    325   DVLOG(3) << __FUNCTION__ << " - stream_type: " << stream_type;
    326   if (!CdmDelegate() ||
    327       !CdmDelegate()->Decrypt(stream_type, encrypted, decrypt_cb)) {
    328     decrypt_cb.Run(kError, NULL);
    329   }
    330 }
    331 
    332 void PpapiDecryptor::CancelDecrypt(StreamType stream_type) {
    333   if (!render_loop_proxy_->BelongsToCurrentThread()) {
    334     render_loop_proxy_->PostTask(FROM_HERE,
    335                                  base::Bind(&PpapiDecryptor::CancelDecrypt,
    336                                             weak_ptr_factory_.GetWeakPtr(),
    337                                             stream_type));
    338     return;
    339   }
    340 
    341   DVLOG(1) << __FUNCTION__ << " - stream_type: " << stream_type;
    342   if (CdmDelegate())
    343     CdmDelegate()->CancelDecrypt(stream_type);
    344 }
    345 
    346 void PpapiDecryptor::InitializeAudioDecoder(
    347       const media::AudioDecoderConfig& config,
    348       const DecoderInitCB& init_cb) {
    349   if (!render_loop_proxy_->BelongsToCurrentThread()) {
    350     render_loop_proxy_->PostTask(
    351         FROM_HERE,
    352         base::Bind(&PpapiDecryptor::InitializeAudioDecoder,
    353                    weak_ptr_factory_.GetWeakPtr(),
    354                    config,
    355                    init_cb));
    356     return;
    357   }
    358 
    359   DVLOG(2) << __FUNCTION__;
    360   DCHECK(config.is_encrypted());
    361   DCHECK(config.IsValidConfig());
    362 
    363   audio_decoder_init_cb_ = init_cb;
    364   if (!CdmDelegate() || !CdmDelegate()->InitializeAudioDecoder(
    365                             config,
    366                             base::Bind(&PpapiDecryptor::OnDecoderInitialized,
    367                                        weak_ptr_factory_.GetWeakPtr(),
    368                                        kAudio))) {
    369     base::ResetAndReturn(&audio_decoder_init_cb_).Run(false);
    370     return;
    371   }
    372 }
    373 
    374 void PpapiDecryptor::InitializeVideoDecoder(
    375     const media::VideoDecoderConfig& config,
    376     const DecoderInitCB& init_cb) {
    377   if (!render_loop_proxy_->BelongsToCurrentThread()) {
    378     render_loop_proxy_->PostTask(
    379         FROM_HERE,
    380         base::Bind(&PpapiDecryptor::InitializeVideoDecoder,
    381                    weak_ptr_factory_.GetWeakPtr(),
    382                    config,
    383                    init_cb));
    384     return;
    385   }
    386 
    387   DVLOG(2) << __FUNCTION__;
    388   DCHECK(config.is_encrypted());
    389   DCHECK(config.IsValidConfig());
    390 
    391   video_decoder_init_cb_ = init_cb;
    392   if (!CdmDelegate() || !CdmDelegate()->InitializeVideoDecoder(
    393                             config,
    394                             base::Bind(&PpapiDecryptor::OnDecoderInitialized,
    395                                        weak_ptr_factory_.GetWeakPtr(),
    396                                        kVideo))) {
    397     base::ResetAndReturn(&video_decoder_init_cb_).Run(false);
    398     return;
    399   }
    400 }
    401 
    402 void PpapiDecryptor::DecryptAndDecodeAudio(
    403     const scoped_refptr<media::DecoderBuffer>& encrypted,
    404     const AudioDecodeCB& audio_decode_cb) {
    405   if (!render_loop_proxy_->BelongsToCurrentThread()) {
    406     render_loop_proxy_->PostTask(
    407         FROM_HERE,
    408         base::Bind(&PpapiDecryptor::DecryptAndDecodeAudio,
    409                    weak_ptr_factory_.GetWeakPtr(),
    410                    encrypted,
    411                    audio_decode_cb));
    412     return;
    413   }
    414 
    415   DVLOG(3) << __FUNCTION__;
    416   if (!CdmDelegate() ||
    417       !CdmDelegate()->DecryptAndDecodeAudio(encrypted, audio_decode_cb)) {
    418     audio_decode_cb.Run(kError, AudioBuffers());
    419   }
    420 }
    421 
    422 void PpapiDecryptor::DecryptAndDecodeVideo(
    423     const scoped_refptr<media::DecoderBuffer>& encrypted,
    424     const VideoDecodeCB& video_decode_cb) {
    425   if (!render_loop_proxy_->BelongsToCurrentThread()) {
    426     render_loop_proxy_->PostTask(
    427         FROM_HERE,
    428         base::Bind(&PpapiDecryptor::DecryptAndDecodeVideo,
    429                    weak_ptr_factory_.GetWeakPtr(),
    430                    encrypted,
    431                    video_decode_cb));
    432     return;
    433   }
    434 
    435   DVLOG(3) << __FUNCTION__;
    436   if (!CdmDelegate() ||
    437       !CdmDelegate()->DecryptAndDecodeVideo(encrypted, video_decode_cb)) {
    438     video_decode_cb.Run(kError, NULL);
    439   }
    440 }
    441 
    442 void PpapiDecryptor::ResetDecoder(StreamType stream_type) {
    443   if (!render_loop_proxy_->BelongsToCurrentThread()) {
    444     render_loop_proxy_->PostTask(FROM_HERE,
    445                                  base::Bind(&PpapiDecryptor::ResetDecoder,
    446                                             weak_ptr_factory_.GetWeakPtr(),
    447                                             stream_type));
    448     return;
    449   }
    450 
    451   DVLOG(2) << __FUNCTION__ << " - stream_type: " << stream_type;
    452   if (CdmDelegate())
    453     CdmDelegate()->ResetDecoder(stream_type);
    454 }
    455 
    456 void PpapiDecryptor::DeinitializeDecoder(StreamType stream_type) {
    457   if (!render_loop_proxy_->BelongsToCurrentThread()) {
    458     render_loop_proxy_->PostTask(
    459         FROM_HERE,
    460         base::Bind(&PpapiDecryptor::DeinitializeDecoder,
    461                    weak_ptr_factory_.GetWeakPtr(),
    462                    stream_type));
    463     return;
    464   }
    465 
    466   DVLOG(2) << __FUNCTION__ << " - stream_type: " << stream_type;
    467   if (CdmDelegate())
    468     CdmDelegate()->DeinitializeDecoder(stream_type);
    469 }
    470 
    471 void PpapiDecryptor::OnDecoderInitialized(StreamType stream_type,
    472                                           bool success) {
    473   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    474   switch (stream_type) {
    475     case kAudio:
    476       DCHECK(!audio_decoder_init_cb_.is_null());
    477       base::ResetAndReturn(&audio_decoder_init_cb_).Run(success);
    478       break;
    479     case kVideo:
    480       DCHECK(!video_decoder_init_cb_.is_null());
    481       base::ResetAndReturn(&video_decoder_init_cb_).Run(success);
    482       break;
    483     default:
    484       NOTREACHED();
    485   }
    486 }
    487 
    488 void PpapiDecryptor::OnSessionMessage(const std::string& web_session_id,
    489                                       const std::vector<uint8>& message,
    490                                       const GURL& destination_url) {
    491   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    492   session_message_cb_.Run(web_session_id, message, destination_url);
    493 }
    494 
    495 void PpapiDecryptor::OnSessionKeysChange(const std::string& web_session_id,
    496                                          bool has_additional_usable_key) {
    497   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    498 
    499   // TODO(jrummell): Handling resume playback should be done in the media
    500   // player, not in the Decryptors. http://crbug.com/413413.
    501   if (has_additional_usable_key)
    502     ResumePlayback();
    503 
    504   session_keys_change_cb_.Run(web_session_id, has_additional_usable_key);
    505 }
    506 
    507 void PpapiDecryptor::OnSessionExpirationUpdate(
    508     const std::string& web_session_id,
    509     const base::Time& new_expiry_time) {
    510   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    511   session_expiration_update_cb_.Run(web_session_id, new_expiry_time);
    512 }
    513 
    514 void PpapiDecryptor::OnSessionReady(const std::string& web_session_id) {
    515   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    516 
    517   // TODO(jrummell): Calling ResumePlayback() here should not be necessary once
    518   // OnSessionKeysChange() is called in all cases. http://crbug.com/413413.
    519   ResumePlayback();
    520   session_ready_cb_.Run(web_session_id);
    521 }
    522 
    523 void PpapiDecryptor::OnSessionClosed(const std::string& web_session_id) {
    524   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    525   session_closed_cb_.Run(web_session_id);
    526 }
    527 
    528 void PpapiDecryptor::OnSessionError(const std::string& web_session_id,
    529                                     MediaKeys::Exception exception_code,
    530                                     uint32 system_code,
    531                                     const std::string& error_description) {
    532   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    533   session_error_cb_.Run(
    534       web_session_id, exception_code, system_code, error_description);
    535 }
    536 
    537 void PpapiDecryptor::ResumePlayback() {
    538   // Based on the spec, we need to resume playback when update() completes
    539   // successfully, or when a session is successfully loaded (triggered by
    540   // OnSessionReady()). So we choose to call the NewKeyCBs here.
    541   if (!new_audio_key_cb_.is_null())
    542     new_audio_key_cb_.Run();
    543 
    544   if (!new_video_key_cb_.is_null())
    545     new_video_key_cb_.Run();
    546 }
    547 
    548 void PpapiDecryptor::OnFatalPluginError() {
    549   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    550   pepper_cdm_wrapper_.reset();
    551 }
    552 
    553 ContentDecryptorDelegate* PpapiDecryptor::CdmDelegate() {
    554   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
    555   return (pepper_cdm_wrapper_) ? pepper_cdm_wrapper_->GetCdmDelegate() : NULL;
    556 }
    557 
    558 }  // namespace content
    559