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/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
  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.
  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.
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 383 PPP_ContentDecryptor_Private_Proxy::~PPP_ContentDecryptor_Private_Proxy() {
 384 }
 385
 386 // static
 387 const PPP_ContentDecryptor_Private*
 388     PPP_ContentDecryptor_Private_Proxy::GetProxyInterface() {
 389   return &content_decryptor_interface;
 390 }
 391
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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