ppapi/cpp/private/content_decryptor_private.cc

   1 // Copyright (c) 2012 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 "ppapi/cpp/private/content_decryptor_private.h"
   6
   7 #include <cstring>  // memcpy
   8
   9 #include "ppapi/c/ppb_var.h"
  10 #include "ppapi/c/private/ppb_content_decryptor_private.h"
  11 #include "ppapi/c/private/ppp_content_decryptor_private.h"
  12 #include "ppapi/cpp/instance.h"
  13 #include "ppapi/cpp/instance_handle.h"
  14 #include "ppapi/cpp/logging.h"
  15 #include "ppapi/cpp/module.h"
  16 #include "ppapi/cpp/module_impl.h"
  17 #include "ppapi/cpp/var.h"
  18
  19 namespace pp {
  20
  21 namespace {
  22
  23 static const char kPPPContentDecryptorInterface[] =
  24     PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE;
  25
  26 void Initialize(PP_Instance instance,
  27                 PP_Var key_system_arg) {
  28   void* object =
  29       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
  30   if (!object)
  31     return;
  32
  33   pp::Var key_system_var(pp::PASS_REF, key_system_arg);
  34   if (!key_system_var.is_string())
  35     return;
  36
  37   static_cast<ContentDecryptor_Private*>(object)->Initialize(
  38       key_system_var.AsString());
  39 }
  40
  41 void CreateSession(PP_Instance instance,
  42                    uint32_t promise_id,
  43                    PP_Var init_data_type_arg,
  44                    PP_Var init_data_arg,
  45                    PP_SessionType session_type) {
  46   void* object =
  47       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
  48   if (!object)
  49     return;
  50
  51   pp::Var init_data_type_var(pp::PASS_REF, init_data_type_arg);
  52   if (!init_data_type_var.is_string())
  53     return;
  54
  55   pp::Var init_data_var(pp::PASS_REF, init_data_arg);
  56   if (!init_data_var.is_array_buffer())
  57     return;
  58   pp::VarArrayBuffer init_data_array_buffer(init_data_var);
  59
  60   static_cast<ContentDecryptor_Private*>(object)
  61       ->CreateSession(promise_id,
  62                       init_data_type_var.AsString(),
  63                       init_data_array_buffer,
  64                       session_type);
  65 }
  66
  67 void LoadSession(PP_Instance instance,
  68                  uint32_t promise_id,
  69                  PP_Var web_session_id_arg) {
  70   void* object =
  71       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
  72   if (!object)
  73     return;
  74
  75   pp::Var web_session_id_var(web_session_id_arg);
  76   if (!web_session_id_var.is_string())
  77     return;
  78
  79   static_cast<ContentDecryptor_Private*>(object)
  80       ->LoadSession(promise_id, web_session_id_var.AsString());
  81 }
  82
  83 void UpdateSession(PP_Instance instance,
  84                    uint32_t promise_id,
  85                    PP_Var web_session_id_arg,
  86                    PP_Var response_arg) {
  87   void* object =
  88       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
  89   if (!object)
  90     return;
  91
  92   pp::Var web_session_id_var(web_session_id_arg);
  93   if (!web_session_id_var.is_string())
  94     return;
  95
  96   pp::Var response_var(response_arg);
  97   if (!response_var.is_array_buffer())
  98     return;
  99   pp::VarArrayBuffer response(response_var);
 100
 101   static_cast<ContentDecryptor_Private*>(object)
 102       ->UpdateSession(promise_id, web_session_id_var.AsString(), response);
 103 }
 104
 105 void ReleaseSession(PP_Instance instance,
 106                     uint32_t promise_id,
 107                     PP_Var web_session_id_arg) {
 108   void* object =
 109       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 110   if (!object)
 111     return;
 112
 113   pp::Var web_session_id_var(web_session_id_arg);
 114   if (!web_session_id_var.is_string())
 115     return;
 116
 117   static_cast<ContentDecryptor_Private*>(object)
 118       ->ReleaseSession(promise_id, web_session_id_var.AsString());
 119 }
 120
 121 void Decrypt(PP_Instance instance,
 122              PP_Resource encrypted_resource,
 123              const PP_EncryptedBlockInfo* encrypted_block_info) {
 124   pp::Buffer_Dev encrypted_block(encrypted_resource);
 125
 126   void* object =
 127       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 128   if (!object)
 129     return;
 130
 131   static_cast<ContentDecryptor_Private*>(object)->Decrypt(
 132       encrypted_block,
 133       *encrypted_block_info);
 134 }
 135
 136 void InitializeAudioDecoder(
 137     PP_Instance instance,
 138     const PP_AudioDecoderConfig* decoder_config,
 139     PP_Resource extra_data_resource) {
 140   pp::Buffer_Dev extra_data_buffer(extra_data_resource);
 141
 142   void* object =
 143       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 144   if (!object)
 145     return;
 146
 147   static_cast<ContentDecryptor_Private*>(object)->InitializeAudioDecoder(
 148       *decoder_config,
 149       extra_data_buffer);
 150 }
 151
 152 void InitializeVideoDecoder(
 153     PP_Instance instance,
 154     const PP_VideoDecoderConfig* decoder_config,
 155     PP_Resource extra_data_resource) {
 156   pp::Buffer_Dev extra_data_buffer(extra_data_resource);
 157
 158   void* object =
 159       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 160   if (!object)
 161     return;
 162
 163   static_cast<ContentDecryptor_Private*>(object)->InitializeVideoDecoder(
 164       *decoder_config,
 165       extra_data_buffer);
 166 }
 167
 168 void DeinitializeDecoder(PP_Instance instance,
 169                          PP_DecryptorStreamType decoder_type,
 170                          uint32_t request_id) {
 171   void* object =
 172       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 173   if (!object)
 174     return;
 175   static_cast<ContentDecryptor_Private*>(object)->DeinitializeDecoder(
 176       decoder_type,
 177       request_id);
 178 }
 179
 180 void ResetDecoder(PP_Instance instance,
 181                   PP_DecryptorStreamType decoder_type,
 182                   uint32_t request_id) {
 183   void* object =
 184       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 185   if (!object)
 186     return;
 187   static_cast<ContentDecryptor_Private*>(object)->ResetDecoder(decoder_type,
 188                                                                request_id);
 189 }
 190
 191 void DecryptAndDecode(PP_Instance instance,
 192                       PP_DecryptorStreamType decoder_type,
 193                       PP_Resource encrypted_resource,
 194                       const PP_EncryptedBlockInfo* encrypted_block_info) {
 195   pp::Buffer_Dev encrypted_buffer(encrypted_resource);
 196
 197   void* object =
 198       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 199   if (!object)
 200     return;
 201
 202   static_cast<ContentDecryptor_Private*>(object)->DecryptAndDecode(
 203       decoder_type,
 204       encrypted_buffer,
 205       *encrypted_block_info);
 206 }
 207
 208 const PPP_ContentDecryptor_Private ppp_content_decryptor = {
 209   &Initialize,
 210   &CreateSession,
 211   &LoadSession,
 212   &UpdateSession,
 213   &ReleaseSession,
 214   &Decrypt,
 215   &InitializeAudioDecoder,
 216   &InitializeVideoDecoder,
 217   &DeinitializeDecoder,
 218   &ResetDecoder,
 219   &DecryptAndDecode
 220 };
 221
 222 template <> const char* interface_name<PPB_ContentDecryptor_Private>() {
 223   return PPB_CONTENTDECRYPTOR_PRIVATE_INTERFACE;
 224 }
 225
 226 }  // namespace
 227
 228 ContentDecryptor_Private::ContentDecryptor_Private(Instance* instance)
 229     : associated_instance_(instance) {
 230   Module::Get()->AddPluginInterface(kPPPContentDecryptorInterface,
 231                                     &ppp_content_decryptor);
 232   instance->AddPerInstanceObject(kPPPContentDecryptorInterface, this);
 233 }
 234
 235 ContentDecryptor_Private::~ContentDecryptor_Private() {
 236   Instance::RemovePerInstanceObject(associated_instance_,
 237                                     kPPPContentDecryptorInterface,
 238                                     this);
 239 }
 240
 241 void ContentDecryptor_Private::PromiseResolved(uint32_t promise_id) {
 242   if (has_interface<PPB_ContentDecryptor_Private>()) {
 243     get_interface<PPB_ContentDecryptor_Private>()->PromiseResolved(
 244         associated_instance_.pp_instance(), promise_id);
 245   }
 246 }
 247
 248 void ContentDecryptor_Private::PromiseResolvedWithSession(
 249     uint32_t promise_id,
 250     const std::string& web_session_id) {
 251   if (has_interface<PPB_ContentDecryptor_Private>()) {
 252     pp::Var web_session_id_var(web_session_id);
 253     get_interface<PPB_ContentDecryptor_Private>()->PromiseResolvedWithSession(
 254         associated_instance_.pp_instance(),
 255         promise_id,
 256         web_session_id_var.pp_var());
 257   }
 258 }
 259
 260 void ContentDecryptor_Private::PromiseRejected(
 261     uint32_t promise_id,
 262     PP_CdmExceptionCode exception_code,
 263     uint32_t system_code,
 264     const std::string& error_description) {
 265   if (has_interface<PPB_ContentDecryptor_Private>()) {
 266     pp::Var error_description_var(error_description);
 267     get_interface<PPB_ContentDecryptor_Private>()->PromiseRejected(
 268         associated_instance_.pp_instance(),
 269         promise_id,
 270         exception_code,
 271         system_code,
 272         error_description_var.pp_var());
 273   }
 274 }
 275
 276 void ContentDecryptor_Private::SessionMessage(
 277     const std::string& web_session_id,
 278     pp::VarArrayBuffer message,
 279     const std::string& destination_url) {
 280   if (has_interface<PPB_ContentDecryptor_Private>()) {
 281     pp::Var web_session_id_var(web_session_id);
 282     pp::Var destination_url_var(destination_url);
 283     get_interface<PPB_ContentDecryptor_Private>()->SessionMessage(
 284         associated_instance_.pp_instance(),
 285         web_session_id_var.pp_var(),
 286         message.pp_var(),
 287         destination_url_var.pp_var());
 288   }
 289 }
 290
 291 void ContentDecryptor_Private::SessionReady(const std::string& web_session_id) {
 292   if (has_interface<PPB_ContentDecryptor_Private>()) {
 293     pp::Var web_session_id_var(web_session_id);
 294     get_interface<PPB_ContentDecryptor_Private>()->SessionReady(
 295         associated_instance_.pp_instance(), web_session_id_var.pp_var());
 296   }
 297 }
 298
 299 void ContentDecryptor_Private::SessionClosed(
 300     const std::string& web_session_id) {
 301   if (has_interface<PPB_ContentDecryptor_Private>()) {
 302     pp::Var web_session_id_var(web_session_id);
 303     get_interface<PPB_ContentDecryptor_Private>()->SessionClosed(
 304         associated_instance_.pp_instance(), web_session_id_var.pp_var());
 305   }
 306 }
 307
 308 void ContentDecryptor_Private::SessionError(
 309     const std::string& web_session_id,
 310     PP_CdmExceptionCode exception_code,
 311     uint32_t system_code,
 312     const std::string& error_description) {
 313   if (has_interface<PPB_ContentDecryptor_Private>()) {
 314     pp::Var web_session_id_var(web_session_id);
 315     pp::Var error_description_var(error_description);
 316     get_interface<PPB_ContentDecryptor_Private>()->SessionError(
 317         associated_instance_.pp_instance(),
 318         web_session_id_var.pp_var(),
 319         exception_code,
 320         system_code,
 321         error_description_var.pp_var());
 322   }
 323 }
 324
 325 void ContentDecryptor_Private::DeliverBlock(
 326     pp::Buffer_Dev decrypted_block,
 327     const PP_DecryptedBlockInfo& decrypted_block_info) {
 328   if (has_interface<PPB_ContentDecryptor_Private>()) {
 329     get_interface<PPB_ContentDecryptor_Private>()->DeliverBlock(
 330         associated_instance_.pp_instance(),
 331         decrypted_block.pp_resource(),
 332         &decrypted_block_info);
 333   }
 334 }
 335
 336 void ContentDecryptor_Private::DecoderInitializeDone(
 337     PP_DecryptorStreamType decoder_type,
 338     uint32_t request_id,
 339     bool success) {
 340   if (has_interface<PPB_ContentDecryptor_Private>()) {
 341     get_interface<PPB_ContentDecryptor_Private>()->DecoderInitializeDone(
 342         associated_instance_.pp_instance(),
 343         decoder_type,
 344         request_id,
 345         PP_FromBool(success));
 346   }
 347 }
 348
 349 void ContentDecryptor_Private::DecoderDeinitializeDone(
 350     PP_DecryptorStreamType decoder_type,
 351     uint32_t request_id) {
 352   if (has_interface<PPB_ContentDecryptor_Private>()) {
 353     get_interface<PPB_ContentDecryptor_Private>()->DecoderDeinitializeDone(
 354         associated_instance_.pp_instance(),
 355         decoder_type,
 356         request_id);
 357   }
 358 }
 359
 360 void ContentDecryptor_Private::DecoderResetDone(
 361     PP_DecryptorStreamType decoder_type,
 362     uint32_t request_id) {
 363   if (has_interface<PPB_ContentDecryptor_Private>()) {
 364     get_interface<PPB_ContentDecryptor_Private>()->DecoderResetDone(
 365         associated_instance_.pp_instance(),
 366         decoder_type,
 367         request_id);
 368   }
 369 }
 370
 371 void ContentDecryptor_Private::DeliverFrame(
 372     pp::Buffer_Dev decrypted_frame,
 373     const PP_DecryptedFrameInfo& decrypted_frame_info) {
 374   if (has_interface<PPB_ContentDecryptor_Private>()) {
 375     get_interface<PPB_ContentDecryptor_Private>()->DeliverFrame(
 376         associated_instance_.pp_instance(),
 377         decrypted_frame.pp_resource(),
 378         &decrypted_frame_info);
 379   }
 380 }
 381
 382 void ContentDecryptor_Private::DeliverSamples(
 383     pp::Buffer_Dev audio_frames,
 384     const PP_DecryptedSampleInfo& decrypted_sample_info) {
 385   if (has_interface<PPB_ContentDecryptor_Private>()) {
 386     get_interface<PPB_ContentDecryptor_Private>()->DeliverSamples(
 387         associated_instance_.pp_instance(),
 388         audio_frames.pp_resource(),
 389         &decrypted_sample_info);
 390   }
 391 }
 392
 393 }  // namespace pp