Home | History | Annotate | Download | only in private 
      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 #include "ppapi/cpp/var_array.h"
     19 
     20 namespace pp {
     21 
     22 namespace {
     23 
     24 static const char kPPPContentDecryptorInterface[] =
     25     PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE;
     26 
     27 void Initialize(PP_Instance instance,
     28                 PP_Var key_system_arg) {
     29   void* object =
     30       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
     31   if (!object)
     32     return;
     33 
     34   pp::Var key_system_var(pp::PASS_REF, key_system_arg);
     35   if (!key_system_var.is_string())
     36     return;
     37 
     38   static_cast<ContentDecryptor_Private*>(object)->Initialize(
     39       key_system_var.AsString());
     40 }
     41 
     42 void SetServerCertificate(PP_Instance instance,
     43                           uint32_t promise_id,
     44                           PP_Var server_certificate_arg) {
     45   void* object =
     46       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
     47   if (!object)
     48     return;
     49 
     50   pp::Var server_certificate_var(server_certificate_arg);
     51   if (!server_certificate_var.is_array_buffer())
     52     return;
     53   pp::VarArrayBuffer server_certificate(server_certificate_var);
     54 
     55   static_cast<ContentDecryptor_Private*>(object)
     56       ->SetServerCertificate(promise_id, server_certificate);
     57 }
     58 
     59 void CreateSession(PP_Instance instance,
     60                    uint32_t promise_id,
     61                    PP_Var init_data_type_arg,
     62                    PP_Var init_data_arg,
     63                    PP_SessionType session_type) {
     64   void* object =
     65       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
     66   if (!object)
     67     return;
     68 
     69   pp::Var init_data_type_var(pp::PASS_REF, init_data_type_arg);
     70   if (!init_data_type_var.is_string())
     71     return;
     72 
     73   pp::Var init_data_var(pp::PASS_REF, init_data_arg);
     74   if (!init_data_var.is_array_buffer())
     75     return;
     76   pp::VarArrayBuffer init_data_array_buffer(init_data_var);
     77 
     78   static_cast<ContentDecryptor_Private*>(object)
     79       ->CreateSession(promise_id,
     80                       init_data_type_var.AsString(),
     81                       init_data_array_buffer,
     82                       session_type);
     83 }
     84 
     85 void LoadSession(PP_Instance instance,
     86                  uint32_t promise_id,
     87                  PP_Var web_session_id_arg) {
     88   void* object =
     89       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
     90   if (!object)
     91     return;
     92 
     93   pp::Var web_session_id_var(web_session_id_arg);
     94   if (!web_session_id_var.is_string())
     95     return;
     96 
     97   static_cast<ContentDecryptor_Private*>(object)
     98       ->LoadSession(promise_id, web_session_id_var.AsString());
     99 }
    100 
    101 void UpdateSession(PP_Instance instance,
    102                    uint32_t promise_id,
    103                    PP_Var web_session_id_arg,
    104                    PP_Var response_arg) {
    105   void* object =
    106       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
    107   if (!object)
    108     return;
    109 
    110   pp::Var web_session_id_var(web_session_id_arg);
    111   if (!web_session_id_var.is_string())
    112     return;
    113 
    114   pp::Var response_var(response_arg);
    115   if (!response_var.is_array_buffer())
    116     return;
    117   pp::VarArrayBuffer response(response_var);
    118 
    119   static_cast<ContentDecryptor_Private*>(object)
    120       ->UpdateSession(promise_id, web_session_id_var.AsString(), response);
    121 }
    122 
    123 void CloseSession(PP_Instance instance,
    124                   uint32_t promise_id,
    125                   PP_Var web_session_id_arg) {
    126   void* object =
    127       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
    128   if (!object)
    129     return;
    130 
    131   pp::Var web_session_id_var(web_session_id_arg);
    132   if (!web_session_id_var.is_string())
    133     return;
    134 
    135   static_cast<ContentDecryptor_Private*>(object)
    136       ->CloseSession(promise_id, web_session_id_var.AsString());
    137 }
    138 
    139 void RemoveSession(PP_Instance instance,
    140                    uint32_t promise_id,
    141                    PP_Var web_session_id_arg) {
    142   void* object =
    143       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
    144   if (!object)
    145     return;
    146 
    147   pp::Var web_session_id_var(web_session_id_arg);
    148   if (!web_session_id_var.is_string())
    149     return;
    150 
    151   static_cast<ContentDecryptor_Private*>(object)
    152       ->RemoveSession(promise_id, web_session_id_var.AsString());
    153 }
    154 
    155 void GetUsableKeyIds(PP_Instance instance,
    156                      uint32_t promise_id,
    157                      PP_Var web_session_id_arg) {
    158   void* object =
    159       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
    160   if (!object)
    161     return;
    162 
    163   pp::Var web_session_id_var(web_session_id_arg);
    164   if (!web_session_id_var.is_string())
    165     return;
    166 
    167   static_cast<ContentDecryptor_Private*>(object)
    168       ->GetUsableKeyIds(promise_id, web_session_id_var.AsString());
    169 }
    170 
    171 void Decrypt(PP_Instance instance,
    172              PP_Resource encrypted_resource,
    173              const PP_EncryptedBlockInfo* encrypted_block_info) {
    174   pp::Buffer_Dev encrypted_block(encrypted_resource);
    175 
    176   void* object =
    177       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
    178   if (!object)
    179     return;
    180 
    181   static_cast<ContentDecryptor_Private*>(object)->Decrypt(
    182       encrypted_block,
    183       *encrypted_block_info);
    184 }
    185 
    186 void InitializeAudioDecoder(
    187     PP_Instance instance,
    188     const PP_AudioDecoderConfig* decoder_config,
    189     PP_Resource extra_data_resource) {
    190   pp::Buffer_Dev extra_data_buffer(extra_data_resource);
    191 
    192   void* object =
    193       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
    194   if (!object)
    195     return;
    196 
    197   static_cast<ContentDecryptor_Private*>(object)->InitializeAudioDecoder(
    198       *decoder_config,
    199       extra_data_buffer);
    200 }
    201 
    202 void InitializeVideoDecoder(
    203     PP_Instance instance,
    204     const PP_VideoDecoderConfig* decoder_config,
    205     PP_Resource extra_data_resource) {
    206   pp::Buffer_Dev extra_data_buffer(extra_data_resource);
    207 
    208   void* object =
    209       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
    210   if (!object)
    211     return;
    212 
    213   static_cast<ContentDecryptor_Private*>(object)->InitializeVideoDecoder(
    214       *decoder_config,
    215       extra_data_buffer);
    216 }
    217 
    218 void DeinitializeDecoder(PP_Instance instance,
    219                          PP_DecryptorStreamType decoder_type,
    220                          uint32_t request_id) {
    221   void* object =
    222       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
    223   if (!object)
    224     return;
    225   static_cast<ContentDecryptor_Private*>(object)->DeinitializeDecoder(
    226       decoder_type,
    227       request_id);
    228 }
    229 
    230 void ResetDecoder(PP_Instance instance,
    231                   PP_DecryptorStreamType decoder_type,
    232                   uint32_t request_id) {
    233   void* object =
    234       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
    235   if (!object)
    236     return;
    237   static_cast<ContentDecryptor_Private*>(object)->ResetDecoder(decoder_type,
    238                                                                request_id);
    239 }
    240 
    241 void DecryptAndDecode(PP_Instance instance,
    242                       PP_DecryptorStreamType decoder_type,
    243                       PP_Resource encrypted_resource,
    244                       const PP_EncryptedBlockInfo* encrypted_block_info) {
    245   pp::Buffer_Dev encrypted_buffer(encrypted_resource);
    246 
    247   void* object =
    248       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
    249   if (!object)
    250     return;
    251 
    252   static_cast<ContentDecryptor_Private*>(object)->DecryptAndDecode(
    253       decoder_type,
    254       encrypted_buffer,
    255       *encrypted_block_info);
    256 }
    257 
    258 const PPP_ContentDecryptor_Private ppp_content_decryptor = {
    259     &Initialize,
    260     &SetServerCertificate,
    261     &CreateSession,
    262     &LoadSession,
    263     &UpdateSession,
    264     &CloseSession,
    265     &RemoveSession,
    266     &GetUsableKeyIds,
    267     &Decrypt,
    268     &InitializeAudioDecoder,
    269     &InitializeVideoDecoder,
    270     &DeinitializeDecoder,
    271     &ResetDecoder,
    272     &DecryptAndDecode};
    273 
    274 template <> const char* interface_name<PPB_ContentDecryptor_Private>() {
    275   return PPB_CONTENTDECRYPTOR_PRIVATE_INTERFACE;
    276 }
    277 
    278 }  // namespace
    279 
    280 ContentDecryptor_Private::ContentDecryptor_Private(Instance* instance)
    281     : associated_instance_(instance) {
    282   Module::Get()->AddPluginInterface(kPPPContentDecryptorInterface,
    283                                     &ppp_content_decryptor);
    284   instance->AddPerInstanceObject(kPPPContentDecryptorInterface, this);
    285 }
    286 
    287 ContentDecryptor_Private::~ContentDecryptor_Private() {
    288   Instance::RemovePerInstanceObject(associated_instance_,
    289                                     kPPPContentDecryptorInterface,
    290                                     this);
    291 }
    292 
    293 void ContentDecryptor_Private::PromiseResolved(uint32_t promise_id) {
    294   if (has_interface<PPB_ContentDecryptor_Private>()) {
    295     get_interface<PPB_ContentDecryptor_Private>()->PromiseResolved(
    296         associated_instance_.pp_instance(), promise_id);
    297   }
    298 }
    299 
    300 void ContentDecryptor_Private::PromiseResolvedWithSession(
    301     uint32_t promise_id,
    302     const std::string& web_session_id) {
    303   if (has_interface<PPB_ContentDecryptor_Private>()) {
    304     pp::Var web_session_id_var(web_session_id);
    305     get_interface<PPB_ContentDecryptor_Private>()->PromiseResolvedWithSession(
    306         associated_instance_.pp_instance(),
    307         promise_id,
    308         web_session_id_var.pp_var());
    309   }
    310 }
    311 
    312 void ContentDecryptor_Private::PromiseResolvedWithKeyIds(
    313     uint32_t promise_id,
    314     const std::vector<std::vector<uint8_t> >& key_ids) {
    315   if (has_interface<PPB_ContentDecryptor_Private>()) {
    316     pp::VarArray key_ids_array = pp::VarArray();
    317     key_ids_array.SetLength(key_ids.size());
    318     for (size_t i = 0; i < key_ids.size(); ++i) {
    319       const std::vector<uint8_t>& entry = key_ids[i];
    320       pp::VarArrayBuffer array_buffer(entry.size());
    321       memcpy(array_buffer.Map(), &entry[0], entry.size());
    322       key_ids_array.Set(i, array_buffer);
    323     }
    324     get_interface<PPB_ContentDecryptor_Private>()->PromiseResolvedWithKeyIds(
    325         associated_instance_.pp_instance(), promise_id, key_ids_array.pp_var());
    326   }
    327 }
    328 
    329 void ContentDecryptor_Private::PromiseRejected(
    330     uint32_t promise_id,
    331     PP_CdmExceptionCode exception_code,
    332     uint32_t system_code,
    333     const std::string& error_description) {
    334   if (has_interface<PPB_ContentDecryptor_Private>()) {
    335     pp::Var error_description_var(error_description);
    336     get_interface<PPB_ContentDecryptor_Private>()->PromiseRejected(
    337         associated_instance_.pp_instance(),
    338         promise_id,
    339         exception_code,
    340         system_code,
    341         error_description_var.pp_var());
    342   }
    343 }
    344 
    345 void ContentDecryptor_Private::SessionMessage(
    346     const std::string& web_session_id,
    347     pp::VarArrayBuffer message,
    348     const std::string& destination_url) {
    349   if (has_interface<PPB_ContentDecryptor_Private>()) {
    350     pp::Var web_session_id_var(web_session_id);
    351     pp::Var destination_url_var(destination_url);
    352     get_interface<PPB_ContentDecryptor_Private>()->SessionMessage(
    353         associated_instance_.pp_instance(),
    354         web_session_id_var.pp_var(),
    355         message.pp_var(),
    356         destination_url_var.pp_var());
    357   }
    358 }
    359 
    360 void ContentDecryptor_Private::SessionKeysChange(
    361     const std::string& web_session_id,
    362     bool has_additional_usable_key) {
    363   if (has_interface<PPB_ContentDecryptor_Private>()) {
    364     pp::Var web_session_id_var(web_session_id);
    365     get_interface<PPB_ContentDecryptor_Private>()->SessionKeysChange(
    366         associated_instance_.pp_instance(),
    367         web_session_id_var.pp_var(),
    368         PP_FromBool(has_additional_usable_key));
    369   }
    370 }
    371 
    372 void ContentDecryptor_Private::SessionExpirationChange(
    373     const std::string& web_session_id,
    374     PP_Time new_expiry_time) {
    375   if (has_interface<PPB_ContentDecryptor_Private>()) {
    376     pp::Var web_session_id_var(web_session_id);
    377     get_interface<PPB_ContentDecryptor_Private>()->SessionExpirationChange(
    378         associated_instance_.pp_instance(),
    379         web_session_id_var.pp_var(),
    380         new_expiry_time);
    381   }
    382 }
    383 
    384 void ContentDecryptor_Private::SessionReady(const std::string& web_session_id) {
    385   if (has_interface<PPB_ContentDecryptor_Private>()) {
    386     pp::Var web_session_id_var(web_session_id);
    387     get_interface<PPB_ContentDecryptor_Private>()->SessionReady(
    388         associated_instance_.pp_instance(), web_session_id_var.pp_var());
    389   }
    390 }
    391 
    392 void ContentDecryptor_Private::SessionClosed(
    393     const std::string& web_session_id) {
    394   if (has_interface<PPB_ContentDecryptor_Private>()) {
    395     pp::Var web_session_id_var(web_session_id);
    396     get_interface<PPB_ContentDecryptor_Private>()->SessionClosed(
    397         associated_instance_.pp_instance(), web_session_id_var.pp_var());
    398   }
    399 }
    400 
    401 void ContentDecryptor_Private::SessionError(
    402     const std::string& web_session_id,
    403     PP_CdmExceptionCode exception_code,
    404     uint32_t system_code,
    405     const std::string& error_description) {
    406   if (has_interface<PPB_ContentDecryptor_Private>()) {
    407     pp::Var web_session_id_var(web_session_id);
    408     pp::Var error_description_var(error_description);
    409     get_interface<PPB_ContentDecryptor_Private>()->SessionError(
    410         associated_instance_.pp_instance(),
    411         web_session_id_var.pp_var(),
    412         exception_code,
    413         system_code,
    414         error_description_var.pp_var());
    415   }
    416 }
    417 
    418 void ContentDecryptor_Private::DeliverBlock(
    419     pp::Buffer_Dev decrypted_block,
    420     const PP_DecryptedBlockInfo& decrypted_block_info) {
    421   if (has_interface<PPB_ContentDecryptor_Private>()) {
    422     get_interface<PPB_ContentDecryptor_Private>()->DeliverBlock(
    423         associated_instance_.pp_instance(),
    424         decrypted_block.pp_resource(),
    425         &decrypted_block_info);
    426   }
    427 }
    428 
    429 void ContentDecryptor_Private::DecoderInitializeDone(
    430     PP_DecryptorStreamType decoder_type,
    431     uint32_t request_id,
    432     bool success) {
    433   if (has_interface<PPB_ContentDecryptor_Private>()) {
    434     get_interface<PPB_ContentDecryptor_Private>()->DecoderInitializeDone(
    435         associated_instance_.pp_instance(),
    436         decoder_type,
    437         request_id,
    438         PP_FromBool(success));
    439   }
    440 }
    441 
    442 void ContentDecryptor_Private::DecoderDeinitializeDone(
    443     PP_DecryptorStreamType decoder_type,
    444     uint32_t request_id) {
    445   if (has_interface<PPB_ContentDecryptor_Private>()) {
    446     get_interface<PPB_ContentDecryptor_Private>()->DecoderDeinitializeDone(
    447         associated_instance_.pp_instance(),
    448         decoder_type,
    449         request_id);
    450   }
    451 }
    452 
    453 void ContentDecryptor_Private::DecoderResetDone(
    454     PP_DecryptorStreamType decoder_type,
    455     uint32_t request_id) {
    456   if (has_interface<PPB_ContentDecryptor_Private>()) {
    457     get_interface<PPB_ContentDecryptor_Private>()->DecoderResetDone(
    458         associated_instance_.pp_instance(),
    459         decoder_type,
    460         request_id);
    461   }
    462 }
    463 
    464 void ContentDecryptor_Private::DeliverFrame(
    465     pp::Buffer_Dev decrypted_frame,
    466     const PP_DecryptedFrameInfo& decrypted_frame_info) {
    467   if (has_interface<PPB_ContentDecryptor_Private>()) {
    468     get_interface<PPB_ContentDecryptor_Private>()->DeliverFrame(
    469         associated_instance_.pp_instance(),
    470         decrypted_frame.pp_resource(),
    471         &decrypted_frame_info);
    472   }
    473 }
    474 
    475 void ContentDecryptor_Private::DeliverSamples(
    476     pp::Buffer_Dev audio_frames,
    477     const PP_DecryptedSampleInfo& decrypted_sample_info) {
    478   if (has_interface<PPB_ContentDecryptor_Private>()) {
    479     get_interface<PPB_ContentDecryptor_Private>()->DeliverSamples(
    480         associated_instance_.pp_instance(),
    481         audio_frames.pp_resource(),
    482         &decrypted_sample_info);
    483   }
    484 }
    485 
    486 }  // namespace pp
    487