Home | History | Annotate | Download | only in thunk
      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 // From private/ppb_content_decryptor_private.idl,
      6 //   modified Thu Jun  5 13:39:15 2014.
      7 
      8 #include "ppapi/c/pp_errors.h"
      9 #include "ppapi/c/private/ppb_content_decryptor_private.h"
     10 #include "ppapi/shared_impl/tracked_callback.h"
     11 #include "ppapi/thunk/enter.h"
     12 #include "ppapi/thunk/ppapi_thunk_export.h"
     13 
     14 namespace ppapi {
     15 namespace thunk {
     16 
     17 namespace {
     18 
     19 void PromiseResolved(PP_Instance instance, uint32_t promise_id) {
     20   VLOG(4) << "PPB_ContentDecryptor_Private::PromiseResolved()";
     21   EnterInstance enter(instance);
     22   if (enter.failed())
     23     return;
     24   enter.functions()->PromiseResolved(instance, promise_id);
     25 }
     26 
     27 void PromiseResolvedWithSession(PP_Instance instance,
     28                                 uint32_t promise_id,
     29                                 struct PP_Var web_session_id) {
     30   VLOG(4) << "PPB_ContentDecryptor_Private::PromiseResolvedWithSession()";
     31   EnterInstance enter(instance);
     32   if (enter.failed())
     33     return;
     34   enter.functions()->PromiseResolvedWithSession(instance,
     35                                                 promise_id,
     36                                                 web_session_id);
     37 }
     38 
     39 void PromiseRejected(PP_Instance instance,
     40                      uint32_t promise_id,
     41                      PP_CdmExceptionCode exception_code,
     42                      uint32_t system_code,
     43                      struct PP_Var error_description) {
     44   VLOG(4) << "PPB_ContentDecryptor_Private::PromiseRejected()";
     45   EnterInstance enter(instance);
     46   if (enter.failed())
     47     return;
     48   enter.functions()->PromiseRejected(instance,
     49                                      promise_id,
     50                                      exception_code,
     51                                      system_code,
     52                                      error_description);
     53 }
     54 
     55 void SessionMessage(PP_Instance instance,
     56                     struct PP_Var web_session_id,
     57                     struct PP_Var message,
     58                     struct PP_Var destination_url) {
     59   VLOG(4) << "PPB_ContentDecryptor_Private::SessionMessage()";
     60   EnterInstance enter(instance);
     61   if (enter.failed())
     62     return;
     63   enter.functions()->SessionMessage(instance,
     64                                     web_session_id,
     65                                     message,
     66                                     destination_url);
     67 }
     68 
     69 void SessionReady(PP_Instance instance, struct PP_Var web_session_id) {
     70   VLOG(4) << "PPB_ContentDecryptor_Private::SessionReady()";
     71   EnterInstance enter(instance);
     72   if (enter.failed())
     73     return;
     74   enter.functions()->SessionReady(instance, web_session_id);
     75 }
     76 
     77 void SessionClosed(PP_Instance instance, struct PP_Var web_session_id) {
     78   VLOG(4) << "PPB_ContentDecryptor_Private::SessionClosed()";
     79   EnterInstance enter(instance);
     80   if (enter.failed())
     81     return;
     82   enter.functions()->SessionClosed(instance, web_session_id);
     83 }
     84 
     85 void SessionError(PP_Instance instance,
     86                   struct PP_Var web_session_id,
     87                   PP_CdmExceptionCode exception_code,
     88                   uint32_t system_code,
     89                   struct PP_Var error_description) {
     90   VLOG(4) << "PPB_ContentDecryptor_Private::SessionError()";
     91   EnterInstance enter(instance);
     92   if (enter.failed())
     93     return;
     94   enter.functions()->SessionError(instance,
     95                                   web_session_id,
     96                                   exception_code,
     97                                   system_code,
     98                                   error_description);
     99 }
    100 
    101 void DeliverBlock(PP_Instance instance,
    102                   PP_Resource decrypted_block,
    103                   const struct PP_DecryptedBlockInfo* decrypted_block_info) {
    104   VLOG(4) << "PPB_ContentDecryptor_Private::DeliverBlock()";
    105   EnterInstance enter(instance);
    106   if (enter.failed())
    107     return;
    108   enter.functions()->DeliverBlock(instance,
    109                                   decrypted_block,
    110                                   decrypted_block_info);
    111 }
    112 
    113 void DecoderInitializeDone(PP_Instance instance,
    114                            PP_DecryptorStreamType decoder_type,
    115                            uint32_t request_id,
    116                            PP_Bool success) {
    117   VLOG(4) << "PPB_ContentDecryptor_Private::DecoderInitializeDone()";
    118   EnterInstance enter(instance);
    119   if (enter.failed())
    120     return;
    121   enter.functions()->DecoderInitializeDone(instance,
    122                                            decoder_type,
    123                                            request_id,
    124                                            success);
    125 }
    126 
    127 void DecoderDeinitializeDone(PP_Instance instance,
    128                              PP_DecryptorStreamType decoder_type,
    129                              uint32_t request_id) {
    130   VLOG(4) << "PPB_ContentDecryptor_Private::DecoderDeinitializeDone()";
    131   EnterInstance enter(instance);
    132   if (enter.failed())
    133     return;
    134   enter.functions()->DecoderDeinitializeDone(instance,
    135                                              decoder_type,
    136                                              request_id);
    137 }
    138 
    139 void DecoderResetDone(PP_Instance instance,
    140                       PP_DecryptorStreamType decoder_type,
    141                       uint32_t request_id) {
    142   VLOG(4) << "PPB_ContentDecryptor_Private::DecoderResetDone()";
    143   EnterInstance enter(instance);
    144   if (enter.failed())
    145     return;
    146   enter.functions()->DecoderResetDone(instance, decoder_type, request_id);
    147 }
    148 
    149 void DeliverFrame(PP_Instance instance,
    150                   PP_Resource decrypted_frame,
    151                   const struct PP_DecryptedFrameInfo* decrypted_frame_info) {
    152   VLOG(4) << "PPB_ContentDecryptor_Private::DeliverFrame()";
    153   EnterInstance enter(instance);
    154   if (enter.failed())
    155     return;
    156   enter.functions()->DeliverFrame(instance,
    157                                   decrypted_frame,
    158                                   decrypted_frame_info);
    159 }
    160 
    161 void DeliverSamples(
    162     PP_Instance instance,
    163     PP_Resource audio_frames,
    164     const struct PP_DecryptedSampleInfo* decrypted_sample_info) {
    165   VLOG(4) << "PPB_ContentDecryptor_Private::DeliverSamples()";
    166   EnterInstance enter(instance);
    167   if (enter.failed())
    168     return;
    169   enter.functions()->DeliverSamples(instance,
    170                                     audio_frames,
    171                                     decrypted_sample_info);
    172 }
    173 
    174 const PPB_ContentDecryptor_Private_0_12
    175     g_ppb_contentdecryptor_private_thunk_0_12 = {
    176   &PromiseResolved,
    177   &PromiseResolvedWithSession,
    178   &PromiseRejected,
    179   &SessionMessage,
    180   &SessionReady,
    181   &SessionClosed,
    182   &SessionError,
    183   &DeliverBlock,
    184   &DecoderInitializeDone,
    185   &DecoderDeinitializeDone,
    186   &DecoderResetDone,
    187   &DeliverFrame,
    188   &DeliverSamples
    189 };
    190 
    191 }  // namespace
    192 
    193 PPAPI_THUNK_EXPORT const PPB_ContentDecryptor_Private_0_12*
    194     GetPPB_ContentDecryptor_Private_0_12_Thunk() {
    195   return &g_ppb_contentdecryptor_private_thunk_0_12;
    196 }
    197 
    198 }  // namespace thunk
    199 }  // namespace ppapi
    200