content/renderer/media/crypto/ppapi_decryptor.h

   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 #ifndef CONTENT_RENDERER_MEDIA_CRYPTO_PPAPI_DECRYPTOR_H_
   6 #define CONTENT_RENDERER_MEDIA_CRYPTO_PPAPI_DECRYPTOR_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "content/renderer/media/crypto/pepper_cdm_wrapper.h"
  15 #include "media/base/decryptor.h"
  16 #include "media/base/media_keys.h"
  17 #include "media/base/video_decoder_config.h"
  18
  19 class GURL;
  20
  21 namespace base {
  22 class MessageLoopProxy;
  23 }
  24
  25 namespace content {
  26 class ContentDecryptorDelegate;
  27 class PepperPluginInstanceImpl;
  28
  29 // PpapiDecryptor implements media::MediaKeys and media::Decryptor and forwards
  30 // all calls to the PluginInstance.
  31 // This class should always be created & destroyed on the main renderer thread.
  32 class PpapiDecryptor : public media::MediaKeys, public media::Decryptor {
  33  public:
  34   static scoped_ptr<PpapiDecryptor> Create(
  35       const std::string& key_system,
  36       const GURL& security_origin,
  37       const CreatePepperCdmCB& create_pepper_cdm_cb,
  38       const media::SessionMessageCB& session_message_cb,
  39       const media::SessionReadyCB& session_ready_cb,
  40       const media::SessionClosedCB& session_closed_cb,
  41       const media::SessionErrorCB& session_error_cb,
  42       const media::SessionKeysChangeCB& session_keys_change_cb,
  43       const media::SessionExpirationUpdateCB& session_expiration_update_cb);
  44
  45   ~PpapiDecryptor() override;
  46
  47   // media::MediaKeys implementation.
  48   void SetServerCertificate(
  49       const uint8* certificate_data,
  50       int certificate_data_length,
  51       scoped_ptr<media::SimpleCdmPromise> promise) override;
  52   void CreateSession(const std::string& init_data_type,
  53                      const uint8* init_data,
  54                      int init_data_length,
  55                      SessionType session_type,
  56                      scoped_ptr<media::NewSessionCdmPromise> promise) override;
  57   void LoadSession(const std::string& web_session_id,
  58                    scoped_ptr<media::NewSessionCdmPromise> promise) override;
  59   void UpdateSession(const std::string& web_session_id,
  60                      const uint8* response,
  61                      int response_length,
  62                      scoped_ptr<media::SimpleCdmPromise> promise) override;
  63   void CloseSession(const std::string& web_session_id,
  64                     scoped_ptr<media::SimpleCdmPromise> promise) override;
  65   void RemoveSession(const std::string& web_session_id,
  66                      scoped_ptr<media::SimpleCdmPromise> promise) override;
  67   void GetUsableKeyIds(const std::string& web_session_id,
  68                        scoped_ptr<media::KeyIdsPromise> promise) override;
  69   Decryptor* GetDecryptor() override;
  70
  71   // media::Decryptor implementation.
  72   void RegisterNewKeyCB(StreamType stream_type,
  73                         const NewKeyCB& key_added_cb) override;
  74   void Decrypt(StreamType stream_type,
  75                const scoped_refptr<media::DecoderBuffer>& encrypted,
  76                const DecryptCB& decrypt_cb) override;
  77   void CancelDecrypt(StreamType stream_type) override;
  78   void InitializeAudioDecoder(const media::AudioDecoderConfig& config,
  79                               const DecoderInitCB& init_cb) override;
  80   void InitializeVideoDecoder(const media::VideoDecoderConfig& config,
  81                               const DecoderInitCB& init_cb) override;
  82   void DecryptAndDecodeAudio(
  83       const scoped_refptr<media::DecoderBuffer>& encrypted,
  84       const AudioDecodeCB& audio_decode_cb) override;
  85   void DecryptAndDecodeVideo(
  86       const scoped_refptr<media::DecoderBuffer>& encrypted,
  87       const VideoDecodeCB& video_decode_cb) override;
  88   void ResetDecoder(StreamType stream_type) override;
  89   void DeinitializeDecoder(StreamType stream_type) override;
  90
  91  private:
  92   PpapiDecryptor(
  93       const std::string& key_system,
  94       scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper,
  95       const media::SessionMessageCB& session_message_cb,
  96       const media::SessionReadyCB& session_ready_cb,
  97       const media::SessionClosedCB& session_closed_cb,
  98       const media::SessionErrorCB& session_error_cb,
  99       const media::SessionKeysChangeCB& session_keys_change_cb,
 100       const media::SessionExpirationUpdateCB& session_expiration_update_cb);
 101
 102   void OnDecoderInitialized(StreamType stream_type, bool success);
 103
 104   // Callbacks for |plugin_cdm_delegate_| to fire session events.
 105   void OnSessionMessage(const std::string& web_session_id,
 106                         const std::vector<uint8>& message,
 107                         const GURL& destination_url);
 108   void OnSessionKeysChange(const std::string& web_session_id,
 109                            bool has_additional_usable_key);
 110   void OnSessionExpirationUpdate(const std::string& web_session_id,
 111                                  const base::Time& new_expiry_time);
 112   void OnSessionReady(const std::string& web_session_id);
 113   void OnSessionClosed(const std::string& web_session_id);
 114   void OnSessionError(const std::string& web_session_id,
 115                       MediaKeys::Exception exception_code,
 116                       uint32 system_code,
 117                       const std::string& error_description);
 118
 119   // On a successful Update() or SessionReady event, trigger playback to resume.
 120   void ResumePlayback();
 121
 122   // Callback to notify that a fatal error happened in |plugin_cdm_delegate_|.
 123   // The error is terminal and |plugin_cdm_delegate_| should not be used after
 124   // this call.
 125   void OnFatalPluginError();
 126
 127   ContentDecryptorDelegate* CdmDelegate();
 128
 129   // Hold a reference of the Pepper CDM wrapper to make sure the plugin lives
 130   // as long as needed.
 131   scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper_;
 132
 133   // Callbacks for firing session events.
 134   media::SessionMessageCB session_message_cb_;
 135   media::SessionReadyCB session_ready_cb_;
 136   media::SessionClosedCB session_closed_cb_;
 137   media::SessionErrorCB session_error_cb_;
 138   media::SessionKeysChangeCB session_keys_change_cb_;
 139   media::SessionExpirationUpdateCB session_expiration_update_cb_;
 140
 141   scoped_refptr<base::MessageLoopProxy> render_loop_proxy_;
 142
 143   DecoderInitCB audio_decoder_init_cb_;
 144   DecoderInitCB video_decoder_init_cb_;
 145   NewKeyCB new_audio_key_cb_;
 146   NewKeyCB new_video_key_cb_;
 147
 148   // NOTE: Weak pointers must be invalidated before all other member variables.
 149   base::WeakPtrFactory<PpapiDecryptor> weak_ptr_factory_;
 150
 151   DISALLOW_COPY_AND_ASSIGN(PpapiDecryptor);
 152 };
 153
 154 }  // namespace content
 155
 156 #endif  // CONTENT_RENDERER_MEDIA_CRYPTO_PPAPI_DECRYPTOR_H_