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/proxy/ppp_content_decryptor_private_proxy.h"
6
7 #include "base/platform_file.h"
8 #include "ppapi/c/pp_bool.h"
9 #include "ppapi/c/ppb_core.h"
10 #include "ppapi/proxy/content_decryptor_private_serializer.h"
11 #include "ppapi/proxy/host_dispatcher.h"
12 #include "ppapi/proxy/plugin_globals.h"
13 #include "ppapi/proxy/plugin_resource_tracker.h"
14 #include "ppapi/proxy/ppapi_messages.h"
15 #include "ppapi/proxy/ppb_buffer_proxy.h"
16 #include "ppapi/proxy/serialized_var.h"
17 #include "ppapi/shared_impl/scoped_pp_resource.h"
18 #include "ppapi/shared_impl/var_tracker.h"
19 #include "ppapi/thunk/enter.h"
20 #include "ppapi/thunk/ppb_buffer_api.h"
21 #include "ppapi/thunk/ppb_instance_api.h"
22 #include "ppapi/thunk/thunk.h"
23
24 using ppapi::thunk::EnterResourceNoLock;
25 using ppapi::thunk::PPB_Buffer_API;
26 using ppapi::thunk::PPB_Instance_API;
27
28 namespace ppapi {
29 namespace proxy {
30
31 namespace {
32
DescribeHostBufferResource(PP_Resource resource,uint32_t * size)33 PP_Bool DescribeHostBufferResource(PP_Resource resource, uint32_t* size) {
34 EnterResourceNoLock<PPB_Buffer_API> enter(resource, true);
35 if (enter.failed())
36 return PP_FALSE;
37 return enter.object()->Describe(size);
38 }
39
40 // TODO(dmichael): Refactor so this handle sharing code is in one place.
ShareHostBufferResourceToPlugin(HostDispatcher * dispatcher,PP_Resource resource,base::SharedMemoryHandle * shared_mem_handle)41 PP_Bool ShareHostBufferResourceToPlugin(
42 HostDispatcher* dispatcher,
43 PP_Resource resource,
44 base::SharedMemoryHandle* shared_mem_handle) {
45 if (!dispatcher || resource == 0 || !shared_mem_handle)
46 return PP_FALSE;
47 EnterResourceNoLock<PPB_Buffer_API> enter(resource, true);
48 if (enter.failed())
49 return PP_FALSE;
50 int handle;
51 int32_t result = enter.object()->GetSharedMemory(&handle);
52 if (result != PP_OK)
53 return PP_FALSE;
54 base::PlatformFile platform_file =
55 #if defined(OS_WIN)
56 reinterpret_cast<HANDLE>(static_cast<intptr_t>(handle));
57 #elif defined(OS_POSIX)
58 handle;
59 #else
60 #error Not implemented.
61 #endif
62
63 *shared_mem_handle = dispatcher->ShareHandleWithRemote(platform_file, false);
64 return PP_TRUE;
65 }
66
67 // SerializedVarReceiveInput will decrement the reference count, but we want
68 // to give the recipient a reference. This utility function takes care of that
69 // work for the message handlers defined below.
ExtractReceivedVarAndAddRef(Dispatcher * dispatcher,SerializedVarReceiveInput * serialized_var)70 PP_Var ExtractReceivedVarAndAddRef(Dispatcher* dispatcher,
71 SerializedVarReceiveInput* serialized_var) {
72 PP_Var var = serialized_var->Get(dispatcher);
73 PpapiGlobals::Get()->GetVarTracker()->AddRefVar(var);
74 return var;
75 }
76
InitializePppDecryptorBuffer(PP_Instance instance,HostDispatcher * dispatcher,PP_Resource resource,PPPDecryptor_Buffer * buffer)77 bool InitializePppDecryptorBuffer(PP_Instance instance,
78 HostDispatcher* dispatcher,
79 PP_Resource resource,
80 PPPDecryptor_Buffer* buffer) {
81 if (!buffer) {
82 NOTREACHED();
83 return false;
84 }
85
86 if (resource == 0) {
87 buffer->resource = HostResource();
88 buffer->handle = base::SharedMemoryHandle();
89 buffer->size = 0;
90 return true;
91 }
92
93 HostResource host_resource;
94 host_resource.SetHostResource(instance, resource);
95
96 uint32_t size = 0;
97 if (DescribeHostBufferResource(resource, &size) == PP_FALSE)
98 return false;
99
100 base::SharedMemoryHandle handle;
101 if (ShareHostBufferResourceToPlugin(dispatcher,
102 resource,
103 &handle) == PP_FALSE)
104 return false;
105
106 buffer->resource = host_resource;
107 buffer->handle = handle;
108 buffer->size = size;
109 return true;
110 }
111
Initialize(PP_Instance instance,PP_Var key_system)112 void Initialize(PP_Instance instance,
113 PP_Var key_system) {
114 HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
115 if (!dispatcher) {
116 NOTREACHED();
117 return;
118 }
119
120 dispatcher->Send(
121 new PpapiMsg_PPPContentDecryptor_Initialize(
122 API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
123 instance,
124 SerializedVarSendInput(dispatcher, key_system)));
125 }
126
CreateSession(PP_Instance instance,uint32_t session_id,PP_Var type,PP_Var init_data)127 void CreateSession(PP_Instance instance,
128 uint32_t session_id,
129 PP_Var type,
130 PP_Var init_data) {
131 HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
132 if (!dispatcher) {
133 NOTREACHED();
134 return;
135 }
136
137 dispatcher->Send(new PpapiMsg_PPPContentDecryptor_CreateSession(
138 API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
139 instance,
140 session_id,
141 SerializedVarSendInput(dispatcher, type),
142 SerializedVarSendInput(dispatcher, init_data)));
143 }
144
UpdateSession(PP_Instance instance,uint32_t session_id,PP_Var response)145 void UpdateSession(PP_Instance instance, uint32_t session_id, PP_Var response) {
146 HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
147 if (!dispatcher) {
148 NOTREACHED();
149 return;
150 }
151
152 dispatcher->Send(new PpapiMsg_PPPContentDecryptor_UpdateSession(
153 API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
154 instance,
155 session_id,
156 SerializedVarSendInput(dispatcher, response)));
157 }
158
ReleaseSession(PP_Instance instance,uint32_t session_id)159 void ReleaseSession(PP_Instance instance, uint32_t session_id) {
160 HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
161 if (!dispatcher) {
162 NOTREACHED();
163 return;
164 }
165
166 dispatcher->Send(new PpapiMsg_PPPContentDecryptor_ReleaseSession(
167 API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE, instance, session_id));
168 }
169
Decrypt(PP_Instance instance,PP_Resource encrypted_block,const PP_EncryptedBlockInfo * encrypted_block_info)170 void Decrypt(PP_Instance instance,
171 PP_Resource encrypted_block,
172 const PP_EncryptedBlockInfo* encrypted_block_info) {
173 HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
174 if (!dispatcher) {
175 NOTREACHED();
176 return;
177 }
178
179 PPPDecryptor_Buffer buffer;
180 if (!InitializePppDecryptorBuffer(instance,
181 dispatcher,
182 encrypted_block,
183 &buffer)) {
184 NOTREACHED();
185 return;
186 }
187
188 std::string serialized_block_info;
189 if (!SerializeBlockInfo(*encrypted_block_info, &serialized_block_info)) {
190 NOTREACHED();
191 return;
192 }
193
194 // PluginResourceTracker in the plugin process assumes that resources that it
195 // tracks have been addrefed on behalf of the plugin at the renderer side. So
196 // we explicitly do it for |encryped_block| here.
197 PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(encrypted_block);
198
199 dispatcher->Send(
200 new PpapiMsg_PPPContentDecryptor_Decrypt(
201 API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
202 instance,
203 buffer,
204 serialized_block_info));
205 }
206
InitializeAudioDecoder(PP_Instance instance,const PP_AudioDecoderConfig * decoder_config,PP_Resource extra_data_buffer)207 void InitializeAudioDecoder(
208 PP_Instance instance,
209 const PP_AudioDecoderConfig* decoder_config,
210 PP_Resource extra_data_buffer) {
211 HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
212 if (!dispatcher) {
213 NOTREACHED();
214 return;
215 }
216
217 std::string serialized_decoder_config;
218 if (!SerializeBlockInfo(*decoder_config, &serialized_decoder_config)) {
219 NOTREACHED();
220 return;
221 }
222
223 PPPDecryptor_Buffer buffer;
224 if (!InitializePppDecryptorBuffer(instance,
225 dispatcher,
226 extra_data_buffer,
227 &buffer)) {
228 NOTREACHED();
229 return;
230 }
231
232 // PluginResourceTracker in the plugin process assumes that resources that it
233 // tracks have been addrefed on behalf of the plugin at the renderer side. So
234 // we explicitly do it for |extra_data_buffer| here.
235 PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(extra_data_buffer);
236
237 dispatcher->Send(
238 new PpapiMsg_PPPContentDecryptor_InitializeAudioDecoder(
239 API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
240 instance,
241 serialized_decoder_config,
242 buffer));
243 }
244
InitializeVideoDecoder(PP_Instance instance,const PP_VideoDecoderConfig * decoder_config,PP_Resource extra_data_buffer)245 void InitializeVideoDecoder(
246 PP_Instance instance,
247 const PP_VideoDecoderConfig* decoder_config,
248 PP_Resource extra_data_buffer) {
249 HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
250 if (!dispatcher) {
251 NOTREACHED();
252 return;
253 }
254
255 std::string serialized_decoder_config;
256 if (!SerializeBlockInfo(*decoder_config, &serialized_decoder_config)) {
257 NOTREACHED();
258 return;
259 }
260
261 PPPDecryptor_Buffer buffer;
262 if (!InitializePppDecryptorBuffer(instance,
263 dispatcher,
264 extra_data_buffer,
265 &buffer)) {
266 NOTREACHED();
267 return;
268 }
269
270 // PluginResourceTracker in the plugin process assumes that resources that it
271 // tracks have been addrefed on behalf of the plugin at the renderer side. So
272 // we explicitly do it for |extra_data_buffer| here.
273 PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(extra_data_buffer);
274
275 dispatcher->Send(
276 new PpapiMsg_PPPContentDecryptor_InitializeVideoDecoder(
277 API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
278 instance,
279 serialized_decoder_config,
280 buffer));
281 }
282
283
DeinitializeDecoder(PP_Instance instance,PP_DecryptorStreamType decoder_type,uint32_t request_id)284 void DeinitializeDecoder(PP_Instance instance,
285 PP_DecryptorStreamType decoder_type,
286 uint32_t request_id) {
287 HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
288 if (!dispatcher) {
289 NOTREACHED();
290 return;
291 }
292
293 dispatcher->Send(
294 new PpapiMsg_PPPContentDecryptor_DeinitializeDecoder(
295 API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
296 instance,
297 decoder_type,
298 request_id));
299 }
300
ResetDecoder(PP_Instance instance,PP_DecryptorStreamType decoder_type,uint32_t request_id)301 void ResetDecoder(PP_Instance instance,
302 PP_DecryptorStreamType decoder_type,
303 uint32_t request_id) {
304 HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
305 if (!dispatcher) {
306 NOTREACHED();
307 return;
308 }
309
310 dispatcher->Send(
311 new PpapiMsg_PPPContentDecryptor_ResetDecoder(
312 API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
313 instance,
314 decoder_type,
315 request_id));
316 }
317
DecryptAndDecode(PP_Instance instance,PP_DecryptorStreamType decoder_type,PP_Resource encrypted_buffer,const PP_EncryptedBlockInfo * encrypted_block_info)318 void DecryptAndDecode(PP_Instance instance,
319 PP_DecryptorStreamType decoder_type,
320 PP_Resource encrypted_buffer,
321 const PP_EncryptedBlockInfo* encrypted_block_info) {
322 HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
323 if (!dispatcher) {
324 NOTREACHED();
325 return;
326 }
327
328 PPPDecryptor_Buffer buffer;
329 if (!InitializePppDecryptorBuffer(instance,
330 dispatcher,
331 encrypted_buffer,
332 &buffer)) {
333 NOTREACHED();
334 return;
335 }
336
337 std::string serialized_block_info;
338 if (!SerializeBlockInfo(*encrypted_block_info, &serialized_block_info)) {
339 NOTREACHED();
340 return;
341 }
342
343 // PluginResourceTracker in the plugin process assumes that resources that it
344 // tracks have been addrefed on behalf of the plugin at the renderer side. So
345 // we explicitly do it for |encrypted_buffer| here.
346 PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(encrypted_buffer);
347
348 dispatcher->Send(
349 new PpapiMsg_PPPContentDecryptor_DecryptAndDecode(
350 API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
351 instance,
352 decoder_type,
353 buffer,
354 serialized_block_info));
355 }
356
357 static const PPP_ContentDecryptor_Private content_decryptor_interface = {
358 &Initialize,
359 &CreateSession,
360 &UpdateSession,
361 &ReleaseSession,
362 &Decrypt,
363 &InitializeAudioDecoder,
364 &InitializeVideoDecoder,
365 &DeinitializeDecoder,
366 &ResetDecoder,
367 &DecryptAndDecode
368 };
369
370 } // namespace
371
PPP_ContentDecryptor_Private_Proxy(Dispatcher * dispatcher)372 PPP_ContentDecryptor_Private_Proxy::PPP_ContentDecryptor_Private_Proxy(
373 Dispatcher* dispatcher)
374 : InterfaceProxy(dispatcher),
375 ppp_decryptor_impl_(NULL) {
376 if (dispatcher->IsPlugin()) {
377 ppp_decryptor_impl_ = static_cast<const PPP_ContentDecryptor_Private*>(
378 dispatcher->local_get_interface()(
379 PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE));
380 }
381 }
382
~PPP_ContentDecryptor_Private_Proxy()383 PPP_ContentDecryptor_Private_Proxy::~PPP_ContentDecryptor_Private_Proxy() {
384 }
385
386 // static
387 const PPP_ContentDecryptor_Private*
GetProxyInterface()388 PPP_ContentDecryptor_Private_Proxy::GetProxyInterface() {
389 return &content_decryptor_interface;
390 }
391
OnMessageReceived(const IPC::Message & msg)392 bool PPP_ContentDecryptor_Private_Proxy::OnMessageReceived(
393 const IPC::Message& msg) {
394 if (!dispatcher()->IsPlugin())
395 return false; // These are only valid from host->plugin.
396 // Don't allow the plugin to send these to the host.
397
398 bool handled = true;
399 IPC_BEGIN_MESSAGE_MAP(PPP_ContentDecryptor_Private_Proxy, msg)
400 IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_Initialize,
401 OnMsgInitialize)
402 IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_CreateSession,
403 OnMsgCreateSession)
404 IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_UpdateSession,
405 OnMsgUpdateSession)
406 IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_ReleaseSession,
407 OnMsgReleaseSession)
408 IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_Decrypt,
409 OnMsgDecrypt)
410 IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_InitializeAudioDecoder,
411 OnMsgInitializeAudioDecoder)
412 IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_InitializeVideoDecoder,
413 OnMsgInitializeVideoDecoder)
414 IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_DeinitializeDecoder,
415 OnMsgDeinitializeDecoder)
416 IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_ResetDecoder,
417 OnMsgResetDecoder)
418 IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_DecryptAndDecode,
419 OnMsgDecryptAndDecode)
420 IPC_MESSAGE_UNHANDLED(handled = false)
421 IPC_END_MESSAGE_MAP()
422 DCHECK(handled);
423 return handled;
424 }
425
OnMsgInitialize(PP_Instance instance,SerializedVarReceiveInput key_system)426 void PPP_ContentDecryptor_Private_Proxy::OnMsgInitialize(
427 PP_Instance instance,
428 SerializedVarReceiveInput key_system) {
429 if (ppp_decryptor_impl_) {
430 CallWhileUnlocked(
431 ppp_decryptor_impl_->Initialize,
432 instance,
433 ExtractReceivedVarAndAddRef(dispatcher(), &key_system));
434 }
435 }
436
OnMsgCreateSession(PP_Instance instance,uint32_t session_id,SerializedVarReceiveInput type,SerializedVarReceiveInput init_data)437 void PPP_ContentDecryptor_Private_Proxy::OnMsgCreateSession(
438 PP_Instance instance,
439 uint32_t session_id,
440 SerializedVarReceiveInput type,
441 SerializedVarReceiveInput init_data) {
442 if (ppp_decryptor_impl_) {
443 CallWhileUnlocked(ppp_decryptor_impl_->CreateSession,
444 instance,
445 session_id,
446 ExtractReceivedVarAndAddRef(dispatcher(), &type),
447 ExtractReceivedVarAndAddRef(dispatcher(), &init_data));
448 }
449 }
450
OnMsgUpdateSession(PP_Instance instance,uint32_t session_id,SerializedVarReceiveInput response)451 void PPP_ContentDecryptor_Private_Proxy::OnMsgUpdateSession(
452 PP_Instance instance,
453 uint32_t session_id,
454 SerializedVarReceiveInput response) {
455 if (ppp_decryptor_impl_) {
456 CallWhileUnlocked(ppp_decryptor_impl_->UpdateSession,
457 instance,
458 session_id,
459 ExtractReceivedVarAndAddRef(dispatcher(), &response));
460 }
461 }
462
OnMsgReleaseSession(PP_Instance instance,uint32_t session_id)463 void PPP_ContentDecryptor_Private_Proxy::OnMsgReleaseSession(
464 PP_Instance instance,
465 uint32_t session_id) {
466 if (ppp_decryptor_impl_) {
467 CallWhileUnlocked(ppp_decryptor_impl_->ReleaseSession,
468 instance,
469 session_id);
470 }
471 }
472
OnMsgDecrypt(PP_Instance instance,const PPPDecryptor_Buffer & encrypted_buffer,const std::string & serialized_block_info)473 void PPP_ContentDecryptor_Private_Proxy::OnMsgDecrypt(
474 PP_Instance instance,
475 const PPPDecryptor_Buffer& encrypted_buffer,
476 const std::string& serialized_block_info) {
477 ScopedPPResource plugin_resource(
478 ScopedPPResource::PassRef(),
479 PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
480 encrypted_buffer.handle,
481 encrypted_buffer.size));
482 if (ppp_decryptor_impl_) {
483 PP_EncryptedBlockInfo block_info;
484 if (!DeserializeBlockInfo(serialized_block_info, &block_info))
485 return;
486 CallWhileUnlocked(ppp_decryptor_impl_->Decrypt,
487 instance,
488 plugin_resource.get(),
489 const_cast<const PP_EncryptedBlockInfo*>(&block_info));
490 }
491 }
492
OnMsgInitializeAudioDecoder(PP_Instance instance,const std::string & serialized_decoder_config,const PPPDecryptor_Buffer & extra_data_buffer)493 void PPP_ContentDecryptor_Private_Proxy::OnMsgInitializeAudioDecoder(
494 PP_Instance instance,
495 const std::string& serialized_decoder_config,
496 const PPPDecryptor_Buffer& extra_data_buffer) {
497 ScopedPPResource plugin_resource;
498 if (extra_data_buffer.size > 0) {
499 plugin_resource = ScopedPPResource(
500 ScopedPPResource::PassRef(),
501 PPB_Buffer_Proxy::AddProxyResource(extra_data_buffer.resource,
502 extra_data_buffer.handle,
503 extra_data_buffer.size));
504 }
505
506 PP_AudioDecoderConfig decoder_config;
507 if (!DeserializeBlockInfo(serialized_decoder_config, &decoder_config))
508 return;
509
510 if (ppp_decryptor_impl_) {
511 CallWhileUnlocked(
512 ppp_decryptor_impl_->InitializeAudioDecoder,
513 instance,
514 const_cast<const PP_AudioDecoderConfig*>(&decoder_config),
515 plugin_resource.get());
516 }
517 }
518
OnMsgInitializeVideoDecoder(PP_Instance instance,const std::string & serialized_decoder_config,const PPPDecryptor_Buffer & extra_data_buffer)519 void PPP_ContentDecryptor_Private_Proxy::OnMsgInitializeVideoDecoder(
520 PP_Instance instance,
521 const std::string& serialized_decoder_config,
522 const PPPDecryptor_Buffer& extra_data_buffer) {
523 ScopedPPResource plugin_resource;
524 if (extra_data_buffer.resource.host_resource() != 0) {
525 plugin_resource = ScopedPPResource(
526 ScopedPPResource::PassRef(),
527 PPB_Buffer_Proxy::AddProxyResource(extra_data_buffer.resource,
528 extra_data_buffer.handle,
529 extra_data_buffer.size));
530 }
531
532 PP_VideoDecoderConfig decoder_config;
533 if (!DeserializeBlockInfo(serialized_decoder_config, &decoder_config))
534 return;
535
536 if (ppp_decryptor_impl_) {
537 CallWhileUnlocked(
538 ppp_decryptor_impl_->InitializeVideoDecoder,
539 instance,
540 const_cast<const PP_VideoDecoderConfig*>(&decoder_config),
541 plugin_resource.get());
542 }
543 }
544
OnMsgDeinitializeDecoder(PP_Instance instance,PP_DecryptorStreamType decoder_type,uint32_t request_id)545 void PPP_ContentDecryptor_Private_Proxy::OnMsgDeinitializeDecoder(
546 PP_Instance instance,
547 PP_DecryptorStreamType decoder_type,
548 uint32_t request_id) {
549 if (ppp_decryptor_impl_) {
550 CallWhileUnlocked(
551 ppp_decryptor_impl_->DeinitializeDecoder,
552 instance,
553 decoder_type,
554 request_id);
555 }
556 }
557
OnMsgResetDecoder(PP_Instance instance,PP_DecryptorStreamType decoder_type,uint32_t request_id)558 void PPP_ContentDecryptor_Private_Proxy::OnMsgResetDecoder(
559 PP_Instance instance,
560 PP_DecryptorStreamType decoder_type,
561 uint32_t request_id) {
562 if (ppp_decryptor_impl_) {
563 CallWhileUnlocked(
564 ppp_decryptor_impl_->ResetDecoder,
565 instance,
566 decoder_type,
567 request_id);
568 }
569 }
570
OnMsgDecryptAndDecode(PP_Instance instance,PP_DecryptorStreamType decoder_type,const PPPDecryptor_Buffer & encrypted_buffer,const std::string & serialized_block_info)571 void PPP_ContentDecryptor_Private_Proxy::OnMsgDecryptAndDecode(
572 PP_Instance instance,
573 PP_DecryptorStreamType decoder_type,
574 const PPPDecryptor_Buffer& encrypted_buffer,
575 const std::string& serialized_block_info) {
576 ScopedPPResource plugin_resource;
577 if (encrypted_buffer.resource.host_resource() != 0) {
578 plugin_resource = ScopedPPResource(
579 ScopedPPResource::PassRef(),
580 PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
581 encrypted_buffer.handle,
582 encrypted_buffer.size));
583 }
584
585 if (ppp_decryptor_impl_) {
586 PP_EncryptedBlockInfo block_info;
587 if (!DeserializeBlockInfo(serialized_block_info, &block_info))
588 return;
589 CallWhileUnlocked(
590 ppp_decryptor_impl_->DecryptAndDecode,
591 instance,
592 decoder_type,
593 plugin_resource.get(),
594 const_cast<const PP_EncryptedBlockInfo*>(&block_info));
595 }
596 }
597
598 } // namespace proxy
599 } // namespace ppapi
600