content/renderer/media/crypto/renderer_cdm_manager.h

   1 // Copyright 2014 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_RENDERER_CDM_MANAGER_H_
   6 #define CONTENT_RENDERER_MEDIA_CRYPTO_RENDERER_CDM_MANAGER_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "content/common/media/cdm_messages_enums.h"
  14 #include "content/public/renderer/render_frame_observer.h"
  15 #include "media/base/media_keys.h"
  16 #include "url/gurl.h"
  17
  18 namespace blink {
  19 class WebFrame;
  20 }
  21
  22 namespace content {
  23
  24 class ProxyMediaKeys;
  25
  26 // Class for managing all the CDM objects in the same RenderFrame.
  27 class RendererCdmManager : public RenderFrameObserver {
  28  public:
  29   // Constructs a RendererCdmManager object for the |render_frame|.
  30   explicit RendererCdmManager(RenderFrame* render_frame);
  31   ~RendererCdmManager() override;
  32
  33   // RenderFrameObserver overrides.
  34   bool OnMessageReceived(const IPC::Message& msg) override;
  35
  36   // Encrypted media related methods.
  37   void InitializeCdm(int cdm_id,
  38                      uint32_t promise_id,
  39                      ProxyMediaKeys* media_keys,
  40                      const std::string& key_system,
  41                      const GURL& security_origin,
  42                      bool use_hw_secure_codecs);
  43   void SetServerCertificate(int cdm_id,
  44                             uint32_t promise_id,
  45                             const std::vector<uint8>& certificate);
  46   void CreateSessionAndGenerateRequest(
  47       int cdm_id,
  48       uint32_t promise_id,
  49       media::MediaKeys::SessionType session_type,
  50       CdmHostMsg_CreateSession_InitDataType init_data_type,
  51       const std::vector<uint8>& init_data);
  52   void LoadSession(int cdm_id,
  53                    uint32_t promise_id,
  54                    media::MediaKeys::SessionType session_type,
  55                    const std::string& session_id);
  56   void UpdateSession(int cdm_id,
  57                      uint32_t promise_id,
  58                      const std::string& session_id,
  59                      const std::vector<uint8>& response);
  60   void CloseSession(int cdm_id,
  61                     uint32_t promise_id,
  62                     const std::string& session_id);
  63   void RemoveSession(int cdm_id,
  64                      uint32_t promise_id,
  65                      const std::string& session_id);
  66   void DestroyCdm(int cdm_id);
  67
  68   // Registers a ProxyMediaKeys object. Returns allocated CDM ID.
  69   int RegisterMediaKeys(ProxyMediaKeys* media_keys);
  70
  71   // Unregisters a ProxyMediaKeys object identified by |cdm_id|.
  72   void UnregisterMediaKeys(int cdm_id);
  73
  74  private:
  75   // Gets the pointer to ProxyMediaKeys given the |cdm_id|.
  76   ProxyMediaKeys* GetMediaKeys(int cdm_id);
  77
  78   // Message handlers.
  79   void OnSessionMessage(int cdm_id,
  80                         const std::string& session_id,
  81                         media::MediaKeys::MessageType message_type,
  82                         const std::vector<uint8>& message,
  83                         const GURL& legacy_destination_url);
  84   void OnSessionClosed(int cdm_id, const std::string& session_id);
  85   void OnLegacySessionError(int cdm_id,
  86                             const std::string& session_id,
  87                             media::MediaKeys::Exception exception,
  88                             uint32 system_code,
  89                             const std::string& error_message);
  90   void OnSessionKeysChange(
  91       int cdm_id,
  92       const std::string& session_id,
  93       bool has_additional_usable_key,
  94       const std::vector<media::CdmKeyInformation>& key_info_vector);
  95   void OnSessionExpirationUpdate(int cdm_id,
  96                                  const std::string& session_id,
  97                                  const base::Time& new_expiry_time);
  98
  99   void OnPromiseResolved(int cdm_id, uint32_t promise_id);
 100   void OnPromiseResolvedWithSession(int cdm_id,
 101                                     uint32_t promise_id,
 102                                     const std::string& session_id);
 103   void OnPromiseRejected(int cdm_id,
 104                          uint32_t promise_id,
 105                          media::MediaKeys::Exception exception,
 106                          uint32_t system_code,
 107                          const std::string& error_message);
 108
 109   // CDM ID should be unique per renderer frame.
 110   // TODO(xhwang): Use uint32 to prevent undefined overflow behavior.
 111   int next_cdm_id_;
 112
 113   // CDM ID to ProxyMediaKeys mapping.
 114   std::map<int, ProxyMediaKeys*> proxy_media_keys_map_;
 115
 116   DISALLOW_COPY_AND_ASSIGN(RendererCdmManager);
 117 };
 118
 119 }  // namespace content
 120
 121 #endif  // CONTENT_RENDERER_MEDIA_CRYPTO_RENDERER_CDM_MANAGER_H_