Home | History | Annotate | Download | only in proxy 
      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 GenerateKeyRequest(PP_Instance instance,
    113                         PP_Var key_system,
    114                         PP_Var type,
    115                         PP_Var init_data) {
    116   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
    117   if (!dispatcher) {
    118     NOTREACHED();
    119     return;
    120   }
    121 
    122   dispatcher->Send(
    123       new PpapiMsg_PPPContentDecryptor_GenerateKeyRequest(
    124           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
    125           instance,
    126           SerializedVarSendInput(dispatcher, key_system),
    127           SerializedVarSendInput(dispatcher, type),
    128           SerializedVarSendInput(dispatcher, init_data)));
    129 }
    130 
    131 void AddKey(PP_Instance instance,
    132             PP_Var session_id,
    133             PP_Var key,
    134             PP_Var init_data) {
    135   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
    136   if (!dispatcher) {
    137     NOTREACHED();
    138     return;
    139   }
    140 
    141   dispatcher->Send(
    142       new PpapiMsg_PPPContentDecryptor_AddKey(
    143           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
    144           instance,
    145           SerializedVarSendInput(dispatcher, session_id),
    146           SerializedVarSendInput(dispatcher, key),
    147           SerializedVarSendInput(dispatcher, init_data)));
    148 }
    149 
    150 void CancelKeyRequest(PP_Instance instance, PP_Var session_id) {
    151   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
    152   if (!dispatcher) {
    153     NOTREACHED();
    154     return;
    155   }
    156 
    157   dispatcher->Send(
    158       new PpapiMsg_PPPContentDecryptor_CancelKeyRequest(
    159           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
    160           instance,
    161           SerializedVarSendInput(dispatcher, session_id)));
    162 }
    163 
    164 void Decrypt(PP_Instance instance,
    165              PP_Resource encrypted_block,
    166              const PP_EncryptedBlockInfo* encrypted_block_info) {
    167   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
    168   if (!dispatcher) {
    169     NOTREACHED();
    170     return;
    171   }
    172 
    173   PPPDecryptor_Buffer buffer;
    174   if (!InitializePppDecryptorBuffer(instance,
    175                                     dispatcher,
    176                                     encrypted_block,
    177                                     &buffer)) {
    178     NOTREACHED();
    179     return;
    180   }
    181 
    182   std::string serialized_block_info;
    183   if (!SerializeBlockInfo(*encrypted_block_info, &serialized_block_info)) {
    184     NOTREACHED();
    185     return;
    186   }
    187 
    188   // PluginResourceTracker in the plugin process assumes that resources that it
    189   // tracks have been addrefed on behalf of the plugin at the renderer side. So
    190   // we explicitly do it for |encryped_block| here.
    191   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(encrypted_block);
    192 
    193   dispatcher->Send(
    194       new PpapiMsg_PPPContentDecryptor_Decrypt(
    195           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
    196           instance,
    197           buffer,
    198           serialized_block_info));
    199 }
    200 
    201 void InitializeAudioDecoder(
    202     PP_Instance instance,
    203     const PP_AudioDecoderConfig* decoder_config,
    204     PP_Resource extra_data_buffer) {
    205   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
    206   if (!dispatcher) {
    207     NOTREACHED();
    208     return;
    209   }
    210 
    211   std::string serialized_decoder_config;
    212   if (!SerializeBlockInfo(*decoder_config, &serialized_decoder_config)) {
    213     NOTREACHED();
    214     return;
    215   }
    216 
    217   PPPDecryptor_Buffer buffer;
    218   if (!InitializePppDecryptorBuffer(instance,
    219                                     dispatcher,
    220                                     extra_data_buffer,
    221                                     &buffer)) {
    222     NOTREACHED();
    223     return;
    224   }
    225 
    226   // PluginResourceTracker in the plugin process assumes that resources that it
    227   // tracks have been addrefed on behalf of the plugin at the renderer side. So
    228   // we explicitly do it for |extra_data_buffer| here.
    229   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(extra_data_buffer);
    230 
    231   dispatcher->Send(
    232       new PpapiMsg_PPPContentDecryptor_InitializeAudioDecoder(
    233           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
    234           instance,
    235           serialized_decoder_config,
    236           buffer));
    237 }
    238 
    239 void InitializeVideoDecoder(
    240     PP_Instance instance,
    241     const PP_VideoDecoderConfig* decoder_config,
    242     PP_Resource extra_data_buffer) {
    243   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
    244   if (!dispatcher) {
    245     NOTREACHED();
    246     return;
    247   }
    248 
    249   std::string serialized_decoder_config;
    250   if (!SerializeBlockInfo(*decoder_config, &serialized_decoder_config)) {
    251     NOTREACHED();
    252     return;
    253   }
    254 
    255   PPPDecryptor_Buffer buffer;
    256   if (!InitializePppDecryptorBuffer(instance,
    257                                     dispatcher,
    258                                     extra_data_buffer,
    259                                     &buffer)) {
    260     NOTREACHED();
    261     return;
    262   }
    263 
    264   // PluginResourceTracker in the plugin process assumes that resources that it
    265   // tracks have been addrefed on behalf of the plugin at the renderer side. So
    266   // we explicitly do it for |extra_data_buffer| here.
    267   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(extra_data_buffer);
    268 
    269   dispatcher->Send(
    270       new PpapiMsg_PPPContentDecryptor_InitializeVideoDecoder(
    271           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
    272           instance,
    273           serialized_decoder_config,
    274           buffer));
    275 }
    276 
    277 
    278 void DeinitializeDecoder(PP_Instance instance,
    279                          PP_DecryptorStreamType decoder_type,
    280                          uint32_t request_id) {
    281   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
    282   if (!dispatcher) {
    283     NOTREACHED();
    284     return;
    285   }
    286 
    287   dispatcher->Send(
    288       new PpapiMsg_PPPContentDecryptor_DeinitializeDecoder(
    289           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
    290           instance,
    291           decoder_type,
    292           request_id));
    293 }
    294 
    295 void ResetDecoder(PP_Instance instance,
    296                   PP_DecryptorStreamType decoder_type,
    297                   uint32_t request_id) {
    298   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
    299   if (!dispatcher) {
    300     NOTREACHED();
    301     return;
    302   }
    303 
    304   dispatcher->Send(
    305       new PpapiMsg_PPPContentDecryptor_ResetDecoder(
    306           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
    307           instance,
    308           decoder_type,
    309           request_id));
    310 }
    311 
    312 void DecryptAndDecode(PP_Instance instance,
    313                       PP_DecryptorStreamType decoder_type,
    314                       PP_Resource encrypted_buffer,
    315                       const PP_EncryptedBlockInfo* encrypted_block_info) {
    316   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
    317   if (!dispatcher) {
    318     NOTREACHED();
    319     return;
    320   }
    321 
    322   PPPDecryptor_Buffer buffer;
    323   if (!InitializePppDecryptorBuffer(instance,
    324                                     dispatcher,
    325                                     encrypted_buffer,
    326                                     &buffer)) {
    327     NOTREACHED();
    328     return;
    329   }
    330 
    331   std::string serialized_block_info;
    332   if (!SerializeBlockInfo(*encrypted_block_info, &serialized_block_info)) {
    333     NOTREACHED();
    334     return;
    335   }
    336 
    337   // PluginResourceTracker in the plugin process assumes that resources that it
    338   // tracks have been addrefed on behalf of the plugin at the renderer side. So
    339   // we explicitly do it for |encrypted_buffer| here.
    340   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(encrypted_buffer);
    341 
    342   dispatcher->Send(
    343       new PpapiMsg_PPPContentDecryptor_DecryptAndDecode(
    344           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
    345           instance,
    346           decoder_type,
    347           buffer,
    348           serialized_block_info));
    349 }
    350 
    351 static const PPP_ContentDecryptor_Private content_decryptor_interface = {
    352   &GenerateKeyRequest,
    353   &AddKey,
    354   &CancelKeyRequest,
    355   &Decrypt,
    356   &InitializeAudioDecoder,
    357   &InitializeVideoDecoder,
    358   &DeinitializeDecoder,
    359   &ResetDecoder,
    360   &DecryptAndDecode
    361 };
    362 
    363 }  // namespace
    364 
    365 PPP_ContentDecryptor_Private_Proxy::PPP_ContentDecryptor_Private_Proxy(
    366     Dispatcher* dispatcher)
    367     : InterfaceProxy(dispatcher),
    368       ppp_decryptor_impl_(NULL) {
    369   if (dispatcher->IsPlugin()) {
    370     ppp_decryptor_impl_ = static_cast<const PPP_ContentDecryptor_Private*>(
    371         dispatcher->local_get_interface()(
    372             PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE));
    373   }
    374 }
    375 
    376 PPP_ContentDecryptor_Private_Proxy::~PPP_ContentDecryptor_Private_Proxy() {
    377 }
    378 
    379 // static
    380 const PPP_ContentDecryptor_Private*
    381     PPP_ContentDecryptor_Private_Proxy::GetProxyInterface() {
    382   return &content_decryptor_interface;
    383 }
    384 
    385 bool PPP_ContentDecryptor_Private_Proxy::OnMessageReceived(
    386     const IPC::Message& msg) {
    387   if (!dispatcher()->IsPlugin())
    388     return false;  // These are only valid from host->plugin.
    389                    // Don't allow the plugin to send these to the host.
    390 
    391   bool handled = true;
    392   IPC_BEGIN_MESSAGE_MAP(PPP_ContentDecryptor_Private_Proxy, msg)
    393     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_GenerateKeyRequest,
    394                         OnMsgGenerateKeyRequest)
    395     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_AddKey,
    396                         OnMsgAddKey)
    397     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_CancelKeyRequest,
    398                         OnMsgCancelKeyRequest)
    399     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_Decrypt,
    400                         OnMsgDecrypt)
    401     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_InitializeAudioDecoder,
    402                         OnMsgInitializeAudioDecoder)
    403     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_InitializeVideoDecoder,
    404                         OnMsgInitializeVideoDecoder)
    405     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_DeinitializeDecoder,
    406                         OnMsgDeinitializeDecoder)
    407     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_ResetDecoder,
    408                         OnMsgResetDecoder)
    409     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_DecryptAndDecode,
    410                         OnMsgDecryptAndDecode)
    411     IPC_MESSAGE_UNHANDLED(handled = false)
    412   IPC_END_MESSAGE_MAP()
    413   DCHECK(handled);
    414   return handled;
    415 }
    416 
    417 void PPP_ContentDecryptor_Private_Proxy::OnMsgGenerateKeyRequest(
    418     PP_Instance instance,
    419     SerializedVarReceiveInput key_system,
    420     SerializedVarReceiveInput type,
    421     SerializedVarReceiveInput init_data) {
    422   if (ppp_decryptor_impl_) {
    423     CallWhileUnlocked(ppp_decryptor_impl_->GenerateKeyRequest,
    424                       instance,
    425                       ExtractReceivedVarAndAddRef(dispatcher(), &key_system),
    426                       ExtractReceivedVarAndAddRef(dispatcher(), &type),
    427                       ExtractReceivedVarAndAddRef(dispatcher(), &init_data));
    428   }
    429 }
    430 
    431 void PPP_ContentDecryptor_Private_Proxy::OnMsgAddKey(
    432     PP_Instance instance,
    433     SerializedVarReceiveInput session_id,
    434     SerializedVarReceiveInput key,
    435     SerializedVarReceiveInput init_data) {
    436   if (ppp_decryptor_impl_) {
    437     CallWhileUnlocked(ppp_decryptor_impl_->AddKey,
    438                       instance,
    439                       ExtractReceivedVarAndAddRef(dispatcher(), &session_id),
    440                       ExtractReceivedVarAndAddRef(dispatcher(), &key),
    441                       ExtractReceivedVarAndAddRef(dispatcher(), &init_data));
    442   }
    443 }
    444 
    445 void PPP_ContentDecryptor_Private_Proxy::OnMsgCancelKeyRequest(
    446     PP_Instance instance,
    447     SerializedVarReceiveInput session_id) {
    448   if (ppp_decryptor_impl_) {
    449     CallWhileUnlocked(ppp_decryptor_impl_->CancelKeyRequest,
    450                       instance,
    451                       ExtractReceivedVarAndAddRef(dispatcher(), &session_id));
    452   }
    453 }
    454 
    455 void PPP_ContentDecryptor_Private_Proxy::OnMsgDecrypt(
    456     PP_Instance instance,
    457     const PPPDecryptor_Buffer& encrypted_buffer,
    458     const std::string& serialized_block_info) {
    459   ScopedPPResource plugin_resource(
    460       ScopedPPResource::PassRef(),
    461       PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
    462                                          encrypted_buffer.handle,
    463                                          encrypted_buffer.size));
    464   if (ppp_decryptor_impl_) {
    465     PP_EncryptedBlockInfo block_info;
    466     if (!DeserializeBlockInfo(serialized_block_info, &block_info))
    467       return;
    468     CallWhileUnlocked(ppp_decryptor_impl_->Decrypt,
    469                       instance,
    470                       plugin_resource.get(),
    471                       const_cast<const PP_EncryptedBlockInfo*>(&block_info));
    472   }
    473 }
    474 
    475 void PPP_ContentDecryptor_Private_Proxy::OnMsgInitializeAudioDecoder(
    476     PP_Instance instance,
    477     const std::string& serialized_decoder_config,
    478     const PPPDecryptor_Buffer& extra_data_buffer) {
    479   ScopedPPResource plugin_resource;
    480   if (extra_data_buffer.size > 0) {
    481     plugin_resource = ScopedPPResource(
    482         ScopedPPResource::PassRef(),
    483         PPB_Buffer_Proxy::AddProxyResource(extra_data_buffer.resource,
    484                                            extra_data_buffer.handle,
    485                                            extra_data_buffer.size));
    486   }
    487 
    488   PP_AudioDecoderConfig decoder_config;
    489   if (!DeserializeBlockInfo(serialized_decoder_config, &decoder_config))
    490       return;
    491 
    492   if (ppp_decryptor_impl_) {
    493     CallWhileUnlocked(
    494         ppp_decryptor_impl_->InitializeAudioDecoder,
    495         instance,
    496         const_cast<const PP_AudioDecoderConfig*>(&decoder_config),
    497         plugin_resource.get());
    498   }
    499 }
    500 
    501 void PPP_ContentDecryptor_Private_Proxy::OnMsgInitializeVideoDecoder(
    502     PP_Instance instance,
    503     const std::string& serialized_decoder_config,
    504     const PPPDecryptor_Buffer& extra_data_buffer) {
    505   ScopedPPResource plugin_resource;
    506   if (extra_data_buffer.resource.host_resource() != 0) {
    507     plugin_resource = ScopedPPResource(
    508         ScopedPPResource::PassRef(),
    509         PPB_Buffer_Proxy::AddProxyResource(extra_data_buffer.resource,
    510                                            extra_data_buffer.handle,
    511                                            extra_data_buffer.size));
    512   }
    513 
    514   PP_VideoDecoderConfig decoder_config;
    515   if (!DeserializeBlockInfo(serialized_decoder_config, &decoder_config))
    516       return;
    517 
    518   if (ppp_decryptor_impl_) {
    519     CallWhileUnlocked(
    520         ppp_decryptor_impl_->InitializeVideoDecoder,
    521         instance,
    522         const_cast<const PP_VideoDecoderConfig*>(&decoder_config),
    523         plugin_resource.get());
    524   }
    525 }
    526 
    527 void PPP_ContentDecryptor_Private_Proxy::OnMsgDeinitializeDecoder(
    528     PP_Instance instance,
    529     PP_DecryptorStreamType decoder_type,
    530     uint32_t request_id) {
    531   if (ppp_decryptor_impl_) {
    532     CallWhileUnlocked(
    533         ppp_decryptor_impl_->DeinitializeDecoder,
    534         instance,
    535         decoder_type,
    536         request_id);
    537   }
    538 }
    539 
    540 void PPP_ContentDecryptor_Private_Proxy::OnMsgResetDecoder(
    541     PP_Instance instance,
    542     PP_DecryptorStreamType decoder_type,
    543     uint32_t request_id) {
    544   if (ppp_decryptor_impl_) {
    545     CallWhileUnlocked(
    546         ppp_decryptor_impl_->ResetDecoder,
    547         instance,
    548         decoder_type,
    549         request_id);
    550   }
    551 }
    552 
    553 void PPP_ContentDecryptor_Private_Proxy::OnMsgDecryptAndDecode(
    554     PP_Instance instance,
    555     PP_DecryptorStreamType decoder_type,
    556     const PPPDecryptor_Buffer& encrypted_buffer,
    557     const std::string& serialized_block_info) {
    558   ScopedPPResource plugin_resource;
    559   if (encrypted_buffer.resource.host_resource() != 0) {
    560     plugin_resource = ScopedPPResource(
    561         ScopedPPResource::PassRef(),
    562         PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
    563                                            encrypted_buffer.handle,
    564                                            encrypted_buffer.size));
    565   }
    566 
    567   if (ppp_decryptor_impl_) {
    568     PP_EncryptedBlockInfo block_info;
    569     if (!DeserializeBlockInfo(serialized_block_info, &block_info))
    570       return;
    571     CallWhileUnlocked(
    572         ppp_decryptor_impl_->DecryptAndDecode,
    573         instance,
    574         decoder_type,
    575         plugin_resource.get(),
    576         const_cast<const PP_EncryptedBlockInfo*>(&block_info));
    577   }
    578 }
    579 
    580 }  // namespace proxy
    581 }  // namespace ppapi
    582