xref: /external/chromium_org/media/cdm/ppapi/cdm_adapter.h

// 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.

#ifndef MEDIA_CDM_PPAPI_CDM_ADAPTER_H_
#define MEDIA_CDM_PPAPI_CDM_ADAPTER_H_

#include <string>
#include <vector>

#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "build/build_config.h"
#include "media/cdm/ppapi/api/content_decryption_module.h"
#include "media/cdm/ppapi/cdm_helpers.h"
#include "media/cdm/ppapi/cdm_wrapper.h"
#include "media/cdm/ppapi/linked_ptr.h"
#include "ppapi/c/pp_stdint.h"
#include "ppapi/c/private/pp_content_decryptor.h"
#include "ppapi/cpp/completion_callback.h"
#include "ppapi/cpp/private/content_decryptor_private.h"
#include "ppapi/cpp/var.h"
#include "ppapi/cpp/var_array_buffer.h"
#include "ppapi/utility/completion_callback_factory.h"

#if defined(OS_CHROMEOS)
#include "ppapi/cpp/private/output_protection_private.h"
#include "ppapi/cpp/private/platform_verification.h"
#endif

namespace media {

// GetCdmHostFunc implementation.
void* GetCdmHost(int host_interface_version, void* user_data);

// An adapter class for abstracting away PPAPI interaction and threading for a
// Content Decryption Module (CDM).
class CdmAdapter : public pp::Instance,
                   public pp::ContentDecryptor_Private,
                   public cdm::Host_4,
                   public cdm::Host_6 {
 public:
  CdmAdapter(PP_Instance instance, pp::Module* module);
  virtual ~CdmAdapter();

  // pp::Instance implementation.
  virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
    return true;
  }

  // PPP_ContentDecryptor_Private implementation.
  // Note: Results of calls to these methods must be reported through the
  // PPB_ContentDecryptor_Private interface.
  virtual void Initialize(const std::string& key_system) OVERRIDE;
  virtual void SetServerCertificate(
      uint32_t promise_id,
      pp::VarArrayBuffer server_certificate) OVERRIDE;
  virtual void CreateSession(uint32_t promise_id,
                             const std::string& init_data_type,
                             pp::VarArrayBuffer init_data,
                             PP_SessionType session_type) OVERRIDE;
  virtual void LoadSession(uint32_t promise_id,
                           const std::string& web_session_id) OVERRIDE;
  virtual void UpdateSession(uint32_t promise_id,
                             const std::string& web_session_id,
                             pp::VarArrayBuffer response) OVERRIDE;
  virtual void CloseSession(uint32_t promise_id,
                            const std::string& web_session_id);
  virtual void RemoveSession(uint32_t promise_id,
                             const std::string& web_session_id) OVERRIDE;
  virtual void GetUsableKeyIds(uint32_t promise_id,
                               const std::string& web_session_id) OVERRIDE;
  virtual void Decrypt(
      pp::Buffer_Dev encrypted_buffer,
      const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
  virtual void InitializeAudioDecoder(
      const PP_AudioDecoderConfig& decoder_config,
      pp::Buffer_Dev extra_data_buffer) OVERRIDE;
  virtual void InitializeVideoDecoder(
      const PP_VideoDecoderConfig& decoder_config,
      pp::Buffer_Dev extra_data_buffer) OVERRIDE;
  virtual void DeinitializeDecoder(PP_DecryptorStreamType decoder_type,
                                   uint32_t request_id) OVERRIDE;
  virtual void ResetDecoder(PP_DecryptorStreamType decoder_type,
                            uint32_t request_id) OVERRIDE;
  virtual void DecryptAndDecode(
      PP_DecryptorStreamType decoder_type,
      pp::Buffer_Dev encrypted_buffer,
      const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;

  // cdm::Host_4 and cdm::Host_6 implementation.
  virtual cdm::Buffer* Allocate(uint32_t capacity) OVERRIDE;
  virtual void SetTimer(int64_t delay_ms, void* context) OVERRIDE;

  // cdm::Host_4 implementation.
  virtual double GetCurrentWallTimeInSeconds() OVERRIDE;
  virtual void OnSessionCreated(uint32_t session_id,
                                const char* web_session_id,
                                uint32_t web_session_id_length) OVERRIDE;
  virtual void OnSessionMessage(uint32_t session_id,
                                const char* message,
                                uint32_t message_length,
                                const char* destination_url,
                                uint32_t destination_url_length) OVERRIDE;
  virtual void OnSessionReady(uint32_t session_id) OVERRIDE;
  virtual void OnSessionClosed(uint32_t session_id) OVERRIDE;
  virtual void OnSessionError(uint32_t session_id,
                              cdm::MediaKeyError error_code,
                              uint32_t system_code) OVERRIDE;

  // cdm::Host_6 implementation.
  virtual cdm::Time GetCurrentWallTime() OVERRIDE;
  virtual void OnResolveNewSessionPromise(
      uint32_t promise_id,
      const char* web_session_id,
      uint32_t web_session_id_length) OVERRIDE;
  virtual void OnResolvePromise(uint32_t promise_id) OVERRIDE;
  virtual void OnResolveKeyIdsPromise(uint32_t promise_id,
                                      const cdm::BinaryData* usable_key_ids,
                                      uint32_t usable_key_ids_length) OVERRIDE;
  virtual void OnRejectPromise(uint32_t promise_id,
                               cdm::Error error,
                               uint32_t system_code,
                               const char* error_message,
                               uint32_t error_message_length) OVERRIDE;
  virtual void OnSessionMessage(const char* web_session_id,
                                uint32_t web_session_id_length,
                                const char* message,
                                uint32_t message_length,
                                const char* destination_url,
                                uint32_t destination_url_length) OVERRIDE;
  virtual void OnSessionUsableKeysChange(
      const char* web_session_id,
      uint32_t web_session_id_length,
      bool has_additional_usable_key) OVERRIDE;
  virtual void OnExpirationChange(const char* web_session_id,
                                  uint32_t web_session_id_length,
                                  cdm::Time new_expiry_time) OVERRIDE;
  virtual void OnSessionClosed(const char* web_session_id,
                               uint32_t web_session_id_length) OVERRIDE;
  virtual void OnSessionError(const char* web_session_id,
                              uint32_t web_session_id_length,
                              cdm::Error error,
                              uint32_t system_code,
                              const char* error_message,
                              uint32_t error_message_length) OVERRIDE;

  // cdm::Host_4 and cdm::Host_6 implementation.
  virtual void SendPlatformChallenge(const char* service_id,
                                     uint32_t service_id_length,
                                     const char* challenge,
                                     uint32_t challenge_length) OVERRIDE;
  virtual void EnableOutputProtection(
      uint32_t desired_protection_mask) OVERRIDE;
  virtual void QueryOutputProtectionStatus() OVERRIDE;
  virtual void OnDeferredInitializationDone(
      cdm::StreamType stream_type,
      cdm::Status decoder_status) OVERRIDE;
  virtual cdm::FileIO* CreateFileIO(cdm::FileIOClient* client) OVERRIDE;

 private:
  // These are reported to UMA server. Do not change the existing values!
  enum OutputProtectionStatus {
    OUTPUT_PROTECTION_QUERIED = 0,
    OUTPUT_PROTECTION_NO_EXTERNAL_LINK = 1,
    OUTPUT_PROTECTION_ALL_EXTERNAL_LINKS_PROTECTED = 2,
    OUTPUT_PROTECTION_MAX = 3
  };

  typedef linked_ptr<DecryptedBlockImpl> LinkedDecryptedBlock;
  typedef linked_ptr<VideoFrameImpl> LinkedVideoFrame;
  typedef linked_ptr<AudioFramesImpl> LinkedAudioFrames;

  struct SessionError {
    SessionError(cdm::Error error,
                 uint32_t system_code,
                 std::string error_description);
    cdm::Error error;
    uint32_t system_code;
    std::string error_description;
  };

  bool CreateCdmInstance(const std::string& key_system);

  // <code>PPB_ContentDecryptor_Private</code> dispatchers. These are passed to
  // <code>callback_factory_</code> to ensure that calls into
  // <code>PPP_ContentDecryptor_Private</code> are asynchronous.
  void SendPromiseResolvedInternal(int32_t result, uint32_t promise_id);
  void SendPromiseResolvedWithSessionInternal(
      int32_t result,
      uint32_t promise_id,
      const std::string& web_session_id);
  void SendPromiseResolvedWithUsableKeyIdsInternal(
      int32_t result,
      uint32_t promise_id,
      std::vector<std::vector<uint8> > key_ids);
  void SendPromiseRejectedInternal(int32_t result,
                                   uint32_t promise_id,
                                   const SessionError& error);
  void SendSessionMessageInternal(int32_t result,
                                  const std::string& web_session_id,
                                  const std::vector<uint8>& message,
                                  const std::string& destination_url);
  void SendSessionReadyInternal(int32_t result,
                                const std::string& web_session_id);
  void SendSessionClosedInternal(int32_t result,
                                 const std::string& web_session_id);
  void SendSessionErrorInternal(int32_t result,
                                const std::string& web_session_id,
                                const SessionError& error);
  void SendSessionUsableKeysChangeInternal(int32_t result,
                                           const std::string& web_session_id,
                                           bool has_additional_usable_key);
  void SendExpirationChangeInternal(int32_t result,
                                    const std::string& web_session_id,
                                    cdm::Time new_expiry_time);
  void RejectPromise(uint32_t promise_id,
                     cdm::Error error,
                     uint32_t system_code,
                     const std::string& error_message);

  void DeliverBlock(int32_t result,
                    const cdm::Status& status,
                    const LinkedDecryptedBlock& decrypted_block,
                    const PP_DecryptTrackingInfo& tracking_info);
  void DecoderInitializeDone(int32_t result,
                             PP_DecryptorStreamType decoder_type,
                             uint32_t request_id,
                             bool success);
  void DecoderDeinitializeDone(int32_t result,
                               PP_DecryptorStreamType decoder_type,
                               uint32_t request_id);
  void DecoderResetDone(int32_t result,
                        PP_DecryptorStreamType decoder_type,
                        uint32_t request_id);
  void DeliverFrame(int32_t result,
                    const cdm::Status& status,
                    const LinkedVideoFrame& video_frame,
                    const PP_DecryptTrackingInfo& tracking_info);
  void DeliverSamples(int32_t result,
                      const cdm::Status& status,
                      const LinkedAudioFrames& audio_frames,
                      const PP_DecryptTrackingInfo& tracking_info);

  // Helper for SetTimer().
  void TimerExpired(int32_t result, void* context);

  bool IsValidVideoFrame(const LinkedVideoFrame& video_frame);

  // Callback to report |file_size_bytes| of the first file read by FileIO.
  void OnFirstFileRead(int32_t file_size_bytes);

#if !defined(NDEBUG)
  // Logs the given message to the JavaScript console associated with the
  // CDM adapter instance. The name of the CDM adapter issuing the log message
  // will be automatically prepended to the message.
  void LogToConsole(const pp::Var& value);
#endif  // !defined(NDEBUG)

#if defined(OS_CHROMEOS)
  void ReportOutputProtectionUMA(OutputProtectionStatus status);
  void ReportOutputProtectionQuery();
  void ReportOutputProtectionQueryResult();

  struct PepperPlatformChallengeResponse {
    pp::Var signed_data;
    pp::Var signed_data_signature;
    pp::Var platform_key_certificate;
  };

  void SendPlatformChallengeDone(
      int32_t result,
      const linked_ptr<PepperPlatformChallengeResponse>& response);
  void EnableProtectionDone(int32_t result);
  void QueryOutputProtectionStatusDone(int32_t result);

  pp::OutputProtection_Private output_protection_;
  pp::PlatformVerification platform_verification_;

  // Same as above, these are only read by QueryOutputProtectionStatusDone().
  uint32_t output_link_mask_;
  uint32_t output_protection_mask_;
  bool query_output_protection_in_progress_;

  // Tracks whether an output protection query and a positive query result (no
  // unprotected external link) have been reported to UMA.
  bool uma_for_output_protection_query_reported_;
  bool uma_for_output_protection_positive_result_reported_;
#endif

  PpbBufferAllocator allocator_;
  pp::CompletionCallbackFactory<CdmAdapter> callback_factory_;
  linked_ptr<CdmWrapper> cdm_;
  std::string key_system_;

  // If the CDM returned kDeferredInitialization during InitializeAudioDecoder()
  // or InitializeVideoDecoder(), the (Audio|Video)DecoderConfig.request_id is
  // saved for the future call to OnDeferredInitializationDone().
  bool deferred_initialize_audio_decoder_;
  uint32_t deferred_audio_decoder_config_id_;
  bool deferred_initialize_video_decoder_;
  uint32_t deferred_video_decoder_config_id_;

  uint32_t last_read_file_size_kb_;
  bool file_size_uma_reported_;

  DISALLOW_COPY_AND_ASSIGN(CdmAdapter);
};

}  // namespace media

#endif  // MEDIA_CDM_PPAPI_CDM_ADAPTER_H_