ppapi/proxy/ppp_content_decryptor_private_proxy.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/proxy/ppp_content_decryptor_private_proxy.h"
   6
   7 #include "base/files/file.h"
   8 #include "media/base/limits.h"
   9 #include "ppapi/c/pp_bool.h"
  10 #include "ppapi/c/ppb_core.h"
  11 #include "ppapi/proxy/content_decryptor_private_serializer.h"
  12 #include "ppapi/proxy/host_dispatcher.h"
  13 #include "ppapi/proxy/plugin_globals.h"
  14 #include "ppapi/proxy/plugin_resource_tracker.h"
  15 #include "ppapi/proxy/ppapi_messages.h"
  16 #include "ppapi/proxy/ppb_buffer_proxy.h"
  17 #include "ppapi/proxy/serialized_var.h"
  18 #include "ppapi/shared_impl/scoped_pp_resource.h"
  19 #include "ppapi/shared_impl/scoped_pp_var.h"
  20 #include "ppapi/shared_impl/var_tracker.h"
  21 #include "ppapi/thunk/enter.h"
  22 #include "ppapi/thunk/ppb_buffer_api.h"
  23 #include "ppapi/thunk/ppb_instance_api.h"
  24 #include "ppapi/thunk/thunk.h"
  25
  26 using ppapi::thunk::EnterResourceNoLock;
  27 using ppapi::thunk::PPB_Buffer_API;
  28 using ppapi::thunk::PPB_Instance_API;
  29
  30 namespace ppapi {
  31 namespace proxy {
  32
  33 namespace {
  34
  35 PP_Bool DescribeHostBufferResource(PP_Resource resource, uint32_t* size) {
  36   EnterResourceNoLock<PPB_Buffer_API> enter(resource, true);
  37   if (enter.failed())
  38     return PP_FALSE;
  39   return enter.object()->Describe(size);
  40 }
  41
  42 // TODO(dmichael): Refactor so this handle sharing code is in one place.
  43 PP_Bool ShareHostBufferResourceToPlugin(
  44     HostDispatcher* dispatcher,
  45     PP_Resource resource,
  46     base::SharedMemoryHandle* shared_mem_handle) {
  47   if (!dispatcher || resource == 0 || !shared_mem_handle)
  48     return PP_FALSE;
  49   EnterResourceNoLock<PPB_Buffer_API> enter(resource, true);
  50   if (enter.failed())
  51     return PP_FALSE;
  52   int handle;
  53   int32_t result = enter.object()->GetSharedMemory(&handle);
  54   if (result != PP_OK)
  55     return PP_FALSE;
  56   base::PlatformFile platform_file =
  57   #if defined(OS_WIN)
  58       reinterpret_cast<HANDLE>(static_cast<intptr_t>(handle));
  59   #elif defined(OS_POSIX)
  60       handle;
  61   #else
  62   #error Not implemented.
  63   #endif
  64
  65   *shared_mem_handle = dispatcher->ShareHandleWithRemote(platform_file, false);
  66   return PP_TRUE;
  67 }
  68
  69 // SerializedVarReceiveInput will decrement the reference count, but we want
  70 // to give the recipient a reference. This utility function takes care of that
  71 // work for the message handlers defined below.
  72 PP_Var ExtractReceivedVarAndAddRef(Dispatcher* dispatcher,
  73                                    SerializedVarReceiveInput* serialized_var) {
  74   PP_Var var = serialized_var->Get(dispatcher);
  75   PpapiGlobals::Get()->GetVarTracker()->AddRefVar(var);
  76   return var;
  77 }
  78
  79 bool InitializePppDecryptorBuffer(PP_Instance instance,
  80                                   HostDispatcher* dispatcher,
  81                                   PP_Resource resource,
  82                                   PPPDecryptor_Buffer* buffer) {
  83   if (!buffer) {
  84     NOTREACHED();
  85     return false;
  86   }
  87
  88   if (resource == 0) {
  89     buffer->resource = HostResource();
  90     buffer->handle = base::SharedMemoryHandle();
  91     buffer->size = 0;
  92     return true;
  93   }
  94
  95   HostResource host_resource;
  96   host_resource.SetHostResource(instance, resource);
  97
  98   uint32_t size = 0;
  99   if (DescribeHostBufferResource(resource, &size) == PP_FALSE)
 100     return false;
 101
 102   base::SharedMemoryHandle handle;
 103   if (ShareHostBufferResourceToPlugin(dispatcher,
 104                                       resource,
 105                                       &handle) == PP_FALSE)
 106     return false;
 107
 108   buffer->resource = host_resource;
 109   buffer->handle = handle;
 110   buffer->size = size;
 111   return true;
 112 }
 113
 114 void Initialize(PP_Instance instance,
 115                 PP_Var key_system) {
 116   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 117   if (!dispatcher) {
 118     NOTREACHED();
 119     return;
 120   }
 121
 122   dispatcher->Send(
 123       new PpapiMsg_PPPContentDecryptor_Initialize(
 124           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 125           instance,
 126           SerializedVarSendInput(dispatcher, key_system)));
 127 }
 128
 129 void SetServerCertificate(PP_Instance instance,
 130                           uint32_t promise_id,
 131                           PP_Var server_certificate) {
 132   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 133   if (!dispatcher) {
 134     NOTREACHED();
 135     return;
 136   }
 137
 138   ArrayBufferVar* server_certificate_buffer =
 139       ArrayBufferVar::FromPPVar(server_certificate);
 140   if (!server_certificate_buffer ||
 141       server_certificate_buffer->ByteLength() <
 142           media::limits::kMinCertificateLength ||
 143       server_certificate_buffer->ByteLength() >
 144           media::limits::kMaxCertificateLength) {
 145     NOTREACHED();
 146     return;
 147   }
 148
 149   const uint8_t* server_certificate_ptr =
 150       static_cast<const uint8_t*>(server_certificate_buffer->Map());
 151   const uint32_t server_certificate_size =
 152       server_certificate_buffer->ByteLength();
 153   std::vector<uint8_t> server_certificate_vector(
 154       server_certificate_ptr, server_certificate_ptr + server_certificate_size);
 155
 156   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_SetServerCertificate(
 157       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 158       instance,
 159       promise_id,
 160       server_certificate_vector));
 161 }
 162
 163 void CreateSession(PP_Instance instance,
 164                    uint32_t promise_id,
 165                    PP_Var init_data_type,
 166                    PP_Var init_data,
 167                    PP_SessionType session_type) {
 168   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 169   if (!dispatcher) {
 170     NOTREACHED();
 171     return;
 172   }
 173
 174   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_CreateSession(
 175       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 176       instance,
 177       promise_id,
 178       SerializedVarSendInput(dispatcher, init_data_type),
 179       SerializedVarSendInput(dispatcher, init_data),
 180       session_type));
 181 }
 182
 183 void LoadSession(PP_Instance instance,
 184                  uint32_t promise_id,
 185                  PP_Var web_session_id) {
 186   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 187   if (!dispatcher) {
 188     NOTREACHED();
 189     return;
 190   }
 191
 192   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_LoadSession(
 193       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 194       instance,
 195       promise_id,
 196       SerializedVarSendInput(dispatcher, web_session_id)));
 197 }
 198
 199 void UpdateSession(PP_Instance instance,
 200                    uint32_t promise_id,
 201                    PP_Var web_session_id,
 202                    PP_Var response) {
 203   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 204   if (!dispatcher) {
 205     NOTREACHED();
 206     return;
 207   }
 208
 209   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_UpdateSession(
 210       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 211       instance,
 212       promise_id,
 213       SerializedVarSendInput(dispatcher, web_session_id),
 214       SerializedVarSendInput(dispatcher, response)));
 215 }
 216
 217 void CloseSession(PP_Instance instance,
 218                   uint32_t promise_id,
 219                   PP_Var web_session_id) {
 220   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 221   if (!dispatcher) {
 222     NOTREACHED();
 223     return;
 224   }
 225
 226   StringVar* session_id = StringVar::FromPPVar(web_session_id);
 227   if (!session_id ||
 228       session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
 229     NOTREACHED();
 230     return;
 231   }
 232
 233   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_CloseSession(
 234       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 235       instance,
 236       promise_id,
 237       session_id->value()));
 238 }
 239
 240 void RemoveSession(PP_Instance instance,
 241                    uint32_t promise_id,
 242                    PP_Var web_session_id) {
 243   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 244   if (!dispatcher) {
 245     NOTREACHED();
 246     return;
 247   }
 248
 249   StringVar* session_id = StringVar::FromPPVar(web_session_id);
 250   if (!session_id ||
 251       session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
 252     NOTREACHED();
 253     return;
 254   }
 255
 256   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_RemoveSession(
 257       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 258       instance,
 259       promise_id,
 260       session_id->value()));
 261 }
 262
 263 void GetUsableKeyIds(PP_Instance instance,
 264                      uint32_t promise_id,
 265                      PP_Var web_session_id) {
 266   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 267   if (!dispatcher) {
 268     NOTREACHED();
 269     return;
 270   }
 271
 272   StringVar* session_id = StringVar::FromPPVar(web_session_id);
 273   if (!session_id ||
 274       session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
 275     NOTREACHED();
 276     return;
 277   }
 278
 279   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_GetUsableKeyIds(
 280       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 281       instance,
 282       promise_id,
 283       session_id->value()));
 284 }
 285
 286 void Decrypt(PP_Instance instance,
 287              PP_Resource encrypted_block,
 288              const PP_EncryptedBlockInfo* encrypted_block_info) {
 289   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 290   if (!dispatcher) {
 291     NOTREACHED();
 292     return;
 293   }
 294
 295   PPPDecryptor_Buffer buffer;
 296   if (!InitializePppDecryptorBuffer(instance,
 297                                     dispatcher,
 298                                     encrypted_block,
 299                                     &buffer)) {
 300     NOTREACHED();
 301     return;
 302   }
 303
 304   std::string serialized_block_info;
 305   if (!SerializeBlockInfo(*encrypted_block_info, &serialized_block_info)) {
 306     NOTREACHED();
 307     return;
 308   }
 309
 310   // PluginResourceTracker in the plugin process assumes that resources that it
 311   // tracks have been addrefed on behalf of the plugin at the renderer side. So
 312   // we explicitly do it for |encryped_block| here.
 313   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(encrypted_block);
 314
 315   dispatcher->Send(
 316       new PpapiMsg_PPPContentDecryptor_Decrypt(
 317           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 318           instance,
 319           buffer,
 320           serialized_block_info));
 321 }
 322
 323 void InitializeAudioDecoder(
 324     PP_Instance instance,
 325     const PP_AudioDecoderConfig* decoder_config,
 326     PP_Resource extra_data_buffer) {
 327   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 328   if (!dispatcher) {
 329     NOTREACHED();
 330     return;
 331   }
 332
 333   std::string serialized_decoder_config;
 334   if (!SerializeBlockInfo(*decoder_config, &serialized_decoder_config)) {
 335     NOTREACHED();
 336     return;
 337   }
 338
 339   PPPDecryptor_Buffer buffer;
 340   if (!InitializePppDecryptorBuffer(instance,
 341                                     dispatcher,
 342                                     extra_data_buffer,
 343                                     &buffer)) {
 344     NOTREACHED();
 345     return;
 346   }
 347
 348   // PluginResourceTracker in the plugin process assumes that resources that it
 349   // tracks have been addrefed on behalf of the plugin at the renderer side. So
 350   // we explicitly do it for |extra_data_buffer| here.
 351   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(extra_data_buffer);
 352
 353   dispatcher->Send(
 354       new PpapiMsg_PPPContentDecryptor_InitializeAudioDecoder(
 355           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 356           instance,
 357           serialized_decoder_config,
 358           buffer));
 359 }
 360
 361 void InitializeVideoDecoder(
 362     PP_Instance instance,
 363     const PP_VideoDecoderConfig* decoder_config,
 364     PP_Resource extra_data_buffer) {
 365   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 366   if (!dispatcher) {
 367     NOTREACHED();
 368     return;
 369   }
 370
 371   std::string serialized_decoder_config;
 372   if (!SerializeBlockInfo(*decoder_config, &serialized_decoder_config)) {
 373     NOTREACHED();
 374     return;
 375   }
 376
 377   PPPDecryptor_Buffer buffer;
 378   if (!InitializePppDecryptorBuffer(instance,
 379                                     dispatcher,
 380                                     extra_data_buffer,
 381                                     &buffer)) {
 382     NOTREACHED();
 383     return;
 384   }
 385
 386   // PluginResourceTracker in the plugin process assumes that resources that it
 387   // tracks have been addrefed on behalf of the plugin at the renderer side. So
 388   // we explicitly do it for |extra_data_buffer| here.
 389   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(extra_data_buffer);
 390
 391   dispatcher->Send(
 392       new PpapiMsg_PPPContentDecryptor_InitializeVideoDecoder(
 393           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 394           instance,
 395           serialized_decoder_config,
 396           buffer));
 397 }
 398
 399
 400 void DeinitializeDecoder(PP_Instance instance,
 401                          PP_DecryptorStreamType decoder_type,
 402                          uint32_t request_id) {
 403   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 404   if (!dispatcher) {
 405     NOTREACHED();
 406     return;
 407   }
 408
 409   dispatcher->Send(
 410       new PpapiMsg_PPPContentDecryptor_DeinitializeDecoder(
 411           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 412           instance,
 413           decoder_type,
 414           request_id));
 415 }
 416
 417 void ResetDecoder(PP_Instance instance,
 418                   PP_DecryptorStreamType decoder_type,
 419                   uint32_t request_id) {
 420   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 421   if (!dispatcher) {
 422     NOTREACHED();
 423     return;
 424   }
 425
 426   dispatcher->Send(
 427       new PpapiMsg_PPPContentDecryptor_ResetDecoder(
 428           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 429           instance,
 430           decoder_type,
 431           request_id));
 432 }
 433
 434 void DecryptAndDecode(PP_Instance instance,
 435                       PP_DecryptorStreamType decoder_type,
 436                       PP_Resource encrypted_buffer,
 437                       const PP_EncryptedBlockInfo* encrypted_block_info) {
 438   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 439   if (!dispatcher) {
 440     NOTREACHED();
 441     return;
 442   }
 443
 444   PPPDecryptor_Buffer buffer;
 445   if (!InitializePppDecryptorBuffer(instance,
 446                                     dispatcher,
 447                                     encrypted_buffer,
 448                                     &buffer)) {
 449     NOTREACHED();
 450     return;
 451   }
 452
 453   std::string serialized_block_info;
 454   if (!SerializeBlockInfo(*encrypted_block_info, &serialized_block_info)) {
 455     NOTREACHED();
 456     return;
 457   }
 458
 459   // PluginResourceTracker in the plugin process assumes that resources that it
 460   // tracks have been addrefed on behalf of the plugin at the renderer side. So
 461   // we explicitly do it for |encrypted_buffer| here.
 462   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(encrypted_buffer);
 463
 464   dispatcher->Send(
 465       new PpapiMsg_PPPContentDecryptor_DecryptAndDecode(
 466           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
 467           instance,
 468           decoder_type,
 469           buffer,
 470           serialized_block_info));
 471 }
 472
 473 static const PPP_ContentDecryptor_Private content_decryptor_interface = {
 474     &Initialize,
 475     &SetServerCertificate,
 476     &CreateSession,
 477     &LoadSession,
 478     &UpdateSession,
 479     &CloseSession,
 480     &RemoveSession,
 481     &GetUsableKeyIds,
 482     &Decrypt,
 483     &InitializeAudioDecoder,
 484     &InitializeVideoDecoder,
 485     &DeinitializeDecoder,
 486     &ResetDecoder,
 487     &DecryptAndDecode};
 488
 489 }  // namespace
 490
 491 PPP_ContentDecryptor_Private_Proxy::PPP_ContentDecryptor_Private_Proxy(
 492     Dispatcher* dispatcher)
 493     : InterfaceProxy(dispatcher),
 494       ppp_decryptor_impl_(NULL) {
 495   if (dispatcher->IsPlugin()) {
 496     ppp_decryptor_impl_ = static_cast<const PPP_ContentDecryptor_Private*>(
 497         dispatcher->local_get_interface()(
 498             PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE));
 499   }
 500 }
 501
 502 PPP_ContentDecryptor_Private_Proxy::~PPP_ContentDecryptor_Private_Proxy() {
 503 }
 504
 505 // static
 506 const PPP_ContentDecryptor_Private*
 507     PPP_ContentDecryptor_Private_Proxy::GetProxyInterface() {
 508   return &content_decryptor_interface;
 509 }
 510
 511 bool PPP_ContentDecryptor_Private_Proxy::OnMessageReceived(
 512     const IPC::Message& msg) {
 513   if (!dispatcher()->IsPlugin())
 514     return false;  // These are only valid from host->plugin.
 515                    // Don't allow the plugin to send these to the host.
 516
 517   bool handled = true;
 518   IPC_BEGIN_MESSAGE_MAP(PPP_ContentDecryptor_Private_Proxy, msg)
 519     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_Initialize,
 520                         OnMsgInitialize)
 521     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_SetServerCertificate,
 522                         OnMsgSetServerCertificate)
 523     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_CreateSession,
 524                         OnMsgCreateSession)
 525     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_LoadSession,
 526                         OnMsgLoadSession)
 527     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_UpdateSession,
 528                         OnMsgUpdateSession)
 529     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_CloseSession,
 530                         OnMsgCloseSession)
 531     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_RemoveSession,
 532                         OnMsgRemoveSession)
 533     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_GetUsableKeyIds,
 534                         OnMsgGetUsableKeyIds)
 535     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_Decrypt,
 536                         OnMsgDecrypt)
 537     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_InitializeAudioDecoder,
 538                         OnMsgInitializeAudioDecoder)
 539     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_InitializeVideoDecoder,
 540                         OnMsgInitializeVideoDecoder)
 541     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_DeinitializeDecoder,
 542                         OnMsgDeinitializeDecoder)
 543     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_ResetDecoder,
 544                         OnMsgResetDecoder)
 545     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_DecryptAndDecode,
 546                         OnMsgDecryptAndDecode)
 547     IPC_MESSAGE_UNHANDLED(handled = false)
 548   IPC_END_MESSAGE_MAP()
 549   DCHECK(handled);
 550   return handled;
 551 }
 552
 553 void PPP_ContentDecryptor_Private_Proxy::OnMsgInitialize(
 554     PP_Instance instance,
 555     SerializedVarReceiveInput key_system) {
 556   if (ppp_decryptor_impl_) {
 557     CallWhileUnlocked(
 558         ppp_decryptor_impl_->Initialize,
 559         instance,
 560         ExtractReceivedVarAndAddRef(dispatcher(), &key_system));
 561   }
 562 }
 563
 564 void PPP_ContentDecryptor_Private_Proxy::OnMsgSetServerCertificate(
 565     PP_Instance instance,
 566     uint32_t promise_id,
 567     std::vector<uint8_t> server_certificate) {
 568   if (server_certificate.size() < media::limits::kMinCertificateLength ||
 569       server_certificate.size() > media::limits::kMaxCertificateLength) {
 570     NOTREACHED();
 571     return;
 572   }
 573
 574   if (ppp_decryptor_impl_) {
 575     ScopedPPVar server_certificate_var(
 576         ScopedPPVar::PassRef(),
 577         PpapiGlobals::Get()
 578             ->GetVarTracker()
 579             ->MakeArrayBufferPPVar(server_certificate.size(),
 580                                    &server_certificate[0]));
 581     CallWhileUnlocked(ppp_decryptor_impl_->SetServerCertificate,
 582                       instance,
 583                       promise_id,
 584                       server_certificate_var.get());
 585   }
 586 }
 587
 588 void PPP_ContentDecryptor_Private_Proxy::OnMsgCreateSession(
 589     PP_Instance instance,
 590     uint32_t promise_id,
 591     SerializedVarReceiveInput init_data_type,
 592     SerializedVarReceiveInput init_data,
 593     PP_SessionType session_type) {
 594   if (ppp_decryptor_impl_) {
 595     CallWhileUnlocked(
 596         ppp_decryptor_impl_->CreateSession,
 597         instance,
 598         promise_id,
 599         ExtractReceivedVarAndAddRef(dispatcher(), &init_data_type),
 600         ExtractReceivedVarAndAddRef(dispatcher(), &init_data),
 601         session_type);
 602   }
 603 }
 604
 605 void PPP_ContentDecryptor_Private_Proxy::OnMsgLoadSession(
 606     PP_Instance instance,
 607     uint32_t promise_id,
 608     SerializedVarReceiveInput web_session_id) {
 609   if (ppp_decryptor_impl_) {
 610     CallWhileUnlocked(
 611         ppp_decryptor_impl_->LoadSession,
 612         instance,
 613         promise_id,
 614         ExtractReceivedVarAndAddRef(dispatcher(), &web_session_id));
 615   }
 616 }
 617
 618 void PPP_ContentDecryptor_Private_Proxy::OnMsgUpdateSession(
 619     PP_Instance instance,
 620     uint32_t promise_id,
 621     SerializedVarReceiveInput web_session_id,
 622     SerializedVarReceiveInput response) {
 623   if (ppp_decryptor_impl_) {
 624     CallWhileUnlocked(
 625         ppp_decryptor_impl_->UpdateSession,
 626         instance,
 627         promise_id,
 628         ExtractReceivedVarAndAddRef(dispatcher(), &web_session_id),
 629         ExtractReceivedVarAndAddRef(dispatcher(), &response));
 630   }
 631 }
 632
 633 void PPP_ContentDecryptor_Private_Proxy::OnMsgCloseSession(
 634     PP_Instance instance,
 635     uint32_t promise_id,
 636     const std::string& web_session_id) {
 637   if (ppp_decryptor_impl_) {
 638     ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
 639                                    StringVar::StringToPPVar(web_session_id));
 640     CallWhileUnlocked(ppp_decryptor_impl_->CloseSession,
 641                       instance,
 642                       promise_id,
 643                       web_session_id_var.get());
 644   }
 645 }
 646
 647 void PPP_ContentDecryptor_Private_Proxy::OnMsgRemoveSession(
 648     PP_Instance instance,
 649     uint32_t promise_id,
 650     const std::string& web_session_id) {
 651   if (ppp_decryptor_impl_) {
 652     ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
 653                                    StringVar::StringToPPVar(web_session_id));
 654     CallWhileUnlocked(ppp_decryptor_impl_->RemoveSession,
 655                       instance,
 656                       promise_id,
 657                       web_session_id_var.get());
 658   }
 659 }
 660
 661 void PPP_ContentDecryptor_Private_Proxy::OnMsgGetUsableKeyIds(
 662     PP_Instance instance,
 663     uint32_t promise_id,
 664     const std::string& web_session_id) {
 665   if (ppp_decryptor_impl_) {
 666     ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
 667                                    StringVar::StringToPPVar(web_session_id));
 668     CallWhileUnlocked(ppp_decryptor_impl_->GetUsableKeyIds,
 669                       instance,
 670                       promise_id,
 671                       web_session_id_var.get());
 672   }
 673 }
 674
 675 void PPP_ContentDecryptor_Private_Proxy::OnMsgDecrypt(
 676     PP_Instance instance,
 677     const PPPDecryptor_Buffer& encrypted_buffer,
 678     const std::string& serialized_block_info) {
 679   ScopedPPResource plugin_resource(
 680       ScopedPPResource::PassRef(),
 681       PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
 682                                          encrypted_buffer.handle,
 683                                          encrypted_buffer.size));
 684   if (ppp_decryptor_impl_) {
 685     PP_EncryptedBlockInfo block_info;
 686     if (!DeserializeBlockInfo(serialized_block_info, &block_info))
 687       return;
 688     CallWhileUnlocked(ppp_decryptor_impl_->Decrypt,
 689                       instance,
 690                       plugin_resource.get(),
 691                       &block_info);
 692   }
 693 }
 694
 695 void PPP_ContentDecryptor_Private_Proxy::OnMsgInitializeAudioDecoder(
 696     PP_Instance instance,
 697     const std::string& serialized_decoder_config,
 698     const PPPDecryptor_Buffer& extra_data_buffer) {
 699   ScopedPPResource plugin_resource;
 700   if (extra_data_buffer.size > 0) {
 701     plugin_resource = ScopedPPResource(
 702         ScopedPPResource::PassRef(),
 703         PPB_Buffer_Proxy::AddProxyResource(extra_data_buffer.resource,
 704                                            extra_data_buffer.handle,
 705                                            extra_data_buffer.size));
 706   }
 707
 708   PP_AudioDecoderConfig decoder_config;
 709   if (!DeserializeBlockInfo(serialized_decoder_config, &decoder_config))
 710       return;
 711
 712   if (ppp_decryptor_impl_) {
 713     CallWhileUnlocked(
 714         ppp_decryptor_impl_->InitializeAudioDecoder,
 715         instance,
 716         &decoder_config,
 717         plugin_resource.get());
 718   }
 719 }
 720
 721 void PPP_ContentDecryptor_Private_Proxy::OnMsgInitializeVideoDecoder(
 722     PP_Instance instance,
 723     const std::string& serialized_decoder_config,
 724     const PPPDecryptor_Buffer& extra_data_buffer) {
 725   ScopedPPResource plugin_resource;
 726   if (extra_data_buffer.resource.host_resource() != 0) {
 727     plugin_resource = ScopedPPResource(
 728         ScopedPPResource::PassRef(),
 729         PPB_Buffer_Proxy::AddProxyResource(extra_data_buffer.resource,
 730                                            extra_data_buffer.handle,
 731                                            extra_data_buffer.size));
 732   }
 733
 734   PP_VideoDecoderConfig decoder_config;
 735   if (!DeserializeBlockInfo(serialized_decoder_config, &decoder_config))
 736       return;
 737
 738   if (ppp_decryptor_impl_) {
 739     CallWhileUnlocked(
 740         ppp_decryptor_impl_->InitializeVideoDecoder,
 741         instance,
 742         &decoder_config,
 743         plugin_resource.get());
 744   }
 745 }
 746
 747 void PPP_ContentDecryptor_Private_Proxy::OnMsgDeinitializeDecoder(
 748     PP_Instance instance,
 749     PP_DecryptorStreamType decoder_type,
 750     uint32_t request_id) {
 751   if (ppp_decryptor_impl_) {
 752     CallWhileUnlocked(
 753         ppp_decryptor_impl_->DeinitializeDecoder,
 754         instance,
 755         decoder_type,
 756         request_id);
 757   }
 758 }
 759
 760 void PPP_ContentDecryptor_Private_Proxy::OnMsgResetDecoder(
 761     PP_Instance instance,
 762     PP_DecryptorStreamType decoder_type,
 763     uint32_t request_id) {
 764   if (ppp_decryptor_impl_) {
 765     CallWhileUnlocked(
 766         ppp_decryptor_impl_->ResetDecoder,
 767         instance,
 768         decoder_type,
 769         request_id);
 770   }
 771 }
 772
 773 void PPP_ContentDecryptor_Private_Proxy::OnMsgDecryptAndDecode(
 774     PP_Instance instance,
 775     PP_DecryptorStreamType decoder_type,
 776     const PPPDecryptor_Buffer& encrypted_buffer,
 777     const std::string& serialized_block_info) {
 778   ScopedPPResource plugin_resource;
 779   if (encrypted_buffer.resource.host_resource() != 0) {
 780     plugin_resource = ScopedPPResource(
 781         ScopedPPResource::PassRef(),
 782         PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
 783                                            encrypted_buffer.handle,
 784                                            encrypted_buffer.size));
 785   }
 786
 787   if (ppp_decryptor_impl_) {
 788     PP_EncryptedBlockInfo block_info;
 789     if (!DeserializeBlockInfo(serialized_block_info, &block_info))
 790       return;
 791     CallWhileUnlocked(
 792         ppp_decryptor_impl_->DecryptAndDecode,
 793         instance,
 794         decoder_type,
 795         plugin_resource.get(),
 796         &block_info);
 797   }
 798 }
 799
 800 }  // namespace proxy
 801 }  // namespace ppapi