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 Mon Aug 25 13:52:39 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
14namespace ppapi {
15namespace thunk {
16
17namespace {
18
19void 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
27void 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
39void PromiseResolvedWithKeyIds(PP_Instance instance,
40                               uint32_t promise_id,
41                               struct PP_Var key_ids_array) {
42  VLOG(4) << "PPB_ContentDecryptor_Private::PromiseResolvedWithKeyIds()";
43  EnterInstance enter(instance);
44  if (enter.failed())
45    return;
46  enter.functions()->PromiseResolvedWithKeyIds(instance,
47                                               promise_id,
48                                               key_ids_array);
49}
50
51void PromiseRejected(PP_Instance instance,
52                     uint32_t promise_id,
53                     PP_CdmExceptionCode exception_code,
54                     uint32_t system_code,
55                     struct PP_Var error_description) {
56  VLOG(4) << "PPB_ContentDecryptor_Private::PromiseRejected()";
57  EnterInstance enter(instance);
58  if (enter.failed())
59    return;
60  enter.functions()->PromiseRejected(instance,
61                                     promise_id,
62                                     exception_code,
63                                     system_code,
64                                     error_description);
65}
66
67void SessionMessage(PP_Instance instance,
68                    struct PP_Var web_session_id,
69                    struct PP_Var message,
70                    struct PP_Var destination_url) {
71  VLOG(4) << "PPB_ContentDecryptor_Private::SessionMessage()";
72  EnterInstance enter(instance);
73  if (enter.failed())
74    return;
75  enter.functions()->SessionMessage(instance,
76                                    web_session_id,
77                                    message,
78                                    destination_url);
79}
80
81void SessionKeysChange(PP_Instance instance,
82                       struct PP_Var web_session_id,
83                       PP_Bool has_additional_usable_key) {
84  VLOG(4) << "PPB_ContentDecryptor_Private::SessionKeysChange()";
85  EnterInstance enter(instance);
86  if (enter.failed())
87    return;
88  enter.functions()->SessionKeysChange(instance,
89                                       web_session_id,
90                                       has_additional_usable_key);
91}
92
93void SessionExpirationChange(PP_Instance instance,
94                             struct PP_Var web_session_id,
95                             PP_Time new_expiry_time) {
96  VLOG(4) << "PPB_ContentDecryptor_Private::SessionExpirationChange()";
97  EnterInstance enter(instance);
98  if (enter.failed())
99    return;
100  enter.functions()->SessionExpirationChange(instance,
101                                             web_session_id,
102                                             new_expiry_time);
103}
104
105void SessionReady(PP_Instance instance, struct PP_Var web_session_id) {
106  VLOG(4) << "PPB_ContentDecryptor_Private::SessionReady()";
107  EnterInstance enter(instance);
108  if (enter.failed())
109    return;
110  enter.functions()->SessionReady(instance, web_session_id);
111}
112
113void SessionClosed(PP_Instance instance, struct PP_Var web_session_id) {
114  VLOG(4) << "PPB_ContentDecryptor_Private::SessionClosed()";
115  EnterInstance enter(instance);
116  if (enter.failed())
117    return;
118  enter.functions()->SessionClosed(instance, web_session_id);
119}
120
121void SessionError(PP_Instance instance,
122                  struct PP_Var web_session_id,
123                  PP_CdmExceptionCode exception_code,
124                  uint32_t system_code,
125                  struct PP_Var error_description) {
126  VLOG(4) << "PPB_ContentDecryptor_Private::SessionError()";
127  EnterInstance enter(instance);
128  if (enter.failed())
129    return;
130  enter.functions()->SessionError(instance,
131                                  web_session_id,
132                                  exception_code,
133                                  system_code,
134                                  error_description);
135}
136
137void DeliverBlock(PP_Instance instance,
138                  PP_Resource decrypted_block,
139                  const struct PP_DecryptedBlockInfo* decrypted_block_info) {
140  VLOG(4) << "PPB_ContentDecryptor_Private::DeliverBlock()";
141  EnterInstance enter(instance);
142  if (enter.failed())
143    return;
144  enter.functions()->DeliverBlock(instance,
145                                  decrypted_block,
146                                  decrypted_block_info);
147}
148
149void DecoderInitializeDone(PP_Instance instance,
150                           PP_DecryptorStreamType decoder_type,
151                           uint32_t request_id,
152                           PP_Bool success) {
153  VLOG(4) << "PPB_ContentDecryptor_Private::DecoderInitializeDone()";
154  EnterInstance enter(instance);
155  if (enter.failed())
156    return;
157  enter.functions()->DecoderInitializeDone(instance,
158                                           decoder_type,
159                                           request_id,
160                                           success);
161}
162
163void DecoderDeinitializeDone(PP_Instance instance,
164                             PP_DecryptorStreamType decoder_type,
165                             uint32_t request_id) {
166  VLOG(4) << "PPB_ContentDecryptor_Private::DecoderDeinitializeDone()";
167  EnterInstance enter(instance);
168  if (enter.failed())
169    return;
170  enter.functions()->DecoderDeinitializeDone(instance,
171                                             decoder_type,
172                                             request_id);
173}
174
175void DecoderResetDone(PP_Instance instance,
176                      PP_DecryptorStreamType decoder_type,
177                      uint32_t request_id) {
178  VLOG(4) << "PPB_ContentDecryptor_Private::DecoderResetDone()";
179  EnterInstance enter(instance);
180  if (enter.failed())
181    return;
182  enter.functions()->DecoderResetDone(instance, decoder_type, request_id);
183}
184
185void DeliverFrame(PP_Instance instance,
186                  PP_Resource decrypted_frame,
187                  const struct PP_DecryptedFrameInfo* decrypted_frame_info) {
188  VLOG(4) << "PPB_ContentDecryptor_Private::DeliverFrame()";
189  EnterInstance enter(instance);
190  if (enter.failed())
191    return;
192  enter.functions()->DeliverFrame(instance,
193                                  decrypted_frame,
194                                  decrypted_frame_info);
195}
196
197void DeliverSamples(
198    PP_Instance instance,
199    PP_Resource audio_frames,
200    const struct PP_DecryptedSampleInfo* decrypted_sample_info) {
201  VLOG(4) << "PPB_ContentDecryptor_Private::DeliverSamples()";
202  EnterInstance enter(instance);
203  if (enter.failed())
204    return;
205  enter.functions()->DeliverSamples(instance,
206                                    audio_frames,
207                                    decrypted_sample_info);
208}
209
210const PPB_ContentDecryptor_Private_0_12
211    g_ppb_contentdecryptor_private_thunk_0_12 = {
212  &PromiseResolved,
213  &PromiseResolvedWithSession,
214  &PromiseResolvedWithKeyIds,
215  &PromiseRejected,
216  &SessionMessage,
217  &SessionKeysChange,
218  &SessionExpirationChange,
219  &SessionReady,
220  &SessionClosed,
221  &SessionError,
222  &DeliverBlock,
223  &DecoderInitializeDone,
224  &DecoderDeinitializeDone,
225  &DecoderResetDone,
226  &DeliverFrame,
227  &DeliverSamples
228};
229
230}  // namespace
231
232PPAPI_THUNK_EXPORT const PPB_ContentDecryptor_Private_0_12*
233    GetPPB_ContentDecryptor_Private_0_12_Thunk() {
234  return &g_ppb_contentdecryptor_private_thunk_0_12;
235}
236
237}  // namespace thunk
238}  // namespace ppapi
239