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/ppb_var_deprecated_proxy.h"
      6 
      7 #include <stdlib.h>  // For malloc
      8 
      9 #include "base/bind.h"
     10 #include "base/logging.h"
     11 #include "base/message_loop/message_loop.h"
     12 #include "ppapi/c/dev/ppb_var_deprecated.h"
     13 #include "ppapi/c/pp_var.h"
     14 #include "ppapi/c/ppb_core.h"
     15 #include "ppapi/c/ppb_var.h"
     16 #include "ppapi/proxy/host_dispatcher.h"
     17 #include "ppapi/proxy/plugin_dispatcher.h"
     18 #include "ppapi/proxy/plugin_globals.h"
     19 #include "ppapi/proxy/plugin_resource_tracker.h"
     20 #include "ppapi/proxy/plugin_var_tracker.h"
     21 #include "ppapi/proxy/ppapi_messages.h"
     22 #include "ppapi/proxy/ppp_class_proxy.h"
     23 #include "ppapi/proxy/proxy_object_var.h"
     24 #include "ppapi/proxy/serialized_var.h"
     25 #include "ppapi/shared_impl/ppb_var_shared.h"
     26 #include "ppapi/shared_impl/proxy_lock.h"
     27 #include "ppapi/shared_impl/var.h"
     28 
     29 namespace ppapi {
     30 namespace proxy {
     31 
     32 namespace {
     33 
     34 // Used to do get the set-up information for calling a var object. If the
     35 // exception is set, returns NULL. Otherwise, computes the dispatcher for the
     36 // given var object. If the var is not a valid object, returns NULL and sets
     37 // the exception.
     38 PluginDispatcher* CheckExceptionAndGetDispatcher(const PP_Var& object,
     39                                                  PP_Var* exception) {
     40   // If an exception is already set, we don't need to do anything, just return
     41   // an error to the caller.
     42   if (exception && exception->type != PP_VARTYPE_UNDEFINED)
     43     return NULL;
     44 
     45 
     46   if (object.type == PP_VARTYPE_OBJECT) {
     47     // Get the dispatcher for the object.
     48     PluginDispatcher* dispatcher =
     49         PluginGlobals::Get()->plugin_var_tracker()->
     50             DispatcherForPluginObject(object);
     51     if (dispatcher)
     52       return dispatcher;
     53   }
     54 
     55   // The object is invalid. This means we can't figure out which dispatcher
     56   // to use, which is OK because the call will fail anyway. Set the exception.
     57   if (exception) {
     58     *exception = StringVar::StringToPPVar(
     59         std::string("Attempting to use an invalid object"));
     60   }
     61   return NULL;
     62 }
     63 
     64 // PPB_Var_Deprecated plugin ---------------------------------------------------
     65 
     66 bool HasProperty(PP_Var var,
     67                  PP_Var name,
     68                  PP_Var* exception) {
     69   ProxyAutoLock lock;
     70   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
     71   if (!dispatcher)
     72     return false;
     73 
     74   ReceiveSerializedException se(dispatcher, exception);
     75   PP_Bool result = PP_FALSE;
     76   if (!se.IsThrown()) {
     77     dispatcher->Send(new PpapiHostMsg_PPBVar_HasProperty(
     78         API_ID_PPB_VAR_DEPRECATED,
     79         SerializedVarSendInput(dispatcher, var),
     80         SerializedVarSendInput(dispatcher, name), &se, &result));
     81   }
     82   return PP_ToBool(result);
     83 }
     84 
     85 bool HasMethod(PP_Var var,
     86                PP_Var name,
     87                PP_Var* exception) {
     88   ProxyAutoLock lock;
     89   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
     90   if (!dispatcher)
     91     return false;
     92 
     93   ReceiveSerializedException se(dispatcher, exception);
     94   PP_Bool result = PP_FALSE;
     95   if (!se.IsThrown()) {
     96     dispatcher->Send(new PpapiHostMsg_PPBVar_HasMethodDeprecated(
     97         API_ID_PPB_VAR_DEPRECATED,
     98         SerializedVarSendInput(dispatcher, var),
     99         SerializedVarSendInput(dispatcher, name), &se, &result));
    100   }
    101   return PP_ToBool(result);
    102 }
    103 
    104 PP_Var GetProperty(PP_Var var,
    105                    PP_Var name,
    106                    PP_Var* exception) {
    107   ProxyAutoLock lock;
    108   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
    109   if (!dispatcher)
    110     return PP_MakeUndefined();
    111 
    112   ReceiveSerializedException se(dispatcher, exception);
    113   ReceiveSerializedVarReturnValue result;
    114   if (!se.IsThrown()) {
    115     dispatcher->Send(new PpapiHostMsg_PPBVar_GetProperty(
    116         API_ID_PPB_VAR_DEPRECATED,
    117         SerializedVarSendInput(dispatcher, var),
    118         SerializedVarSendInput(dispatcher, name), &se, &result));
    119   }
    120   return result.Return(dispatcher);
    121 }
    122 
    123 void EnumerateProperties(PP_Var var,
    124                          uint32_t* property_count,
    125                          PP_Var** properties,
    126                          PP_Var* exception) {
    127   ProxyAutoLock lock;
    128   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
    129   if (!dispatcher) {
    130     *property_count = 0;
    131     *properties = NULL;
    132     return;
    133   }
    134 
    135   ReceiveSerializedVarVectorOutParam out_vector(dispatcher,
    136                                                 property_count, properties);
    137   ReceiveSerializedException se(dispatcher, exception);
    138   if (!se.IsThrown()) {
    139     dispatcher->Send(new PpapiHostMsg_PPBVar_EnumerateProperties(
    140         API_ID_PPB_VAR_DEPRECATED,
    141         SerializedVarSendInput(dispatcher, var),
    142         out_vector.OutParam(), &se));
    143   }
    144 }
    145 
    146 void SetProperty(PP_Var var,
    147                  PP_Var name,
    148                  PP_Var value,
    149                  PP_Var* exception) {
    150   ProxyAutoLock lock;
    151   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
    152   if (!dispatcher)
    153     return;
    154 
    155   ReceiveSerializedException se(dispatcher, exception);
    156   if (!se.IsThrown()) {
    157     dispatcher->Send(new PpapiHostMsg_PPBVar_SetPropertyDeprecated(
    158         API_ID_PPB_VAR_DEPRECATED,
    159         SerializedVarSendInput(dispatcher, var),
    160         SerializedVarSendInput(dispatcher, name),
    161         SerializedVarSendInput(dispatcher, value), &se));
    162   }
    163 }
    164 
    165 void RemoveProperty(PP_Var var,
    166                     PP_Var name,
    167                     PP_Var* exception) {
    168   ProxyAutoLock lock;
    169   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
    170   if (!dispatcher)
    171     return;
    172 
    173   ReceiveSerializedException se(dispatcher, exception);
    174   PP_Bool result = PP_FALSE;
    175   if (!se.IsThrown()) {
    176     dispatcher->Send(new PpapiHostMsg_PPBVar_DeleteProperty(
    177         API_ID_PPB_VAR_DEPRECATED,
    178         SerializedVarSendInput(dispatcher, var),
    179         SerializedVarSendInput(dispatcher, name), &se, &result));
    180   }
    181 }
    182 
    183 PP_Var Call(PP_Var object,
    184             PP_Var method_name,
    185             uint32_t argc,
    186             PP_Var* argv,
    187             PP_Var* exception) {
    188   ProxyAutoLock lock;
    189   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(object, exception);
    190   if (!dispatcher)
    191     return PP_MakeUndefined();
    192 
    193   ReceiveSerializedVarReturnValue result;
    194   ReceiveSerializedException se(dispatcher, exception);
    195   if (!se.IsThrown()) {
    196     std::vector<SerializedVar> argv_vect;
    197     SerializedVarSendInput::ConvertVector(dispatcher, argv, argc, &argv_vect);
    198 
    199     dispatcher->Send(new PpapiHostMsg_PPBVar_CallDeprecated(
    200         API_ID_PPB_VAR_DEPRECATED,
    201         SerializedVarSendInput(dispatcher, object),
    202         SerializedVarSendInput(dispatcher, method_name), argv_vect,
    203         &se, &result));
    204   }
    205   return result.Return(dispatcher);
    206 }
    207 
    208 PP_Var Construct(PP_Var object,
    209                  uint32_t argc,
    210                  PP_Var* argv,
    211                  PP_Var* exception) {
    212   ProxyAutoLock lock;
    213   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(object, exception);
    214   if (!dispatcher)
    215     return PP_MakeUndefined();
    216 
    217   ReceiveSerializedVarReturnValue result;
    218   ReceiveSerializedException se(dispatcher, exception);
    219   if (!se.IsThrown()) {
    220     std::vector<SerializedVar> argv_vect;
    221     SerializedVarSendInput::ConvertVector(dispatcher, argv, argc, &argv_vect);
    222 
    223     dispatcher->Send(new PpapiHostMsg_PPBVar_Construct(
    224         API_ID_PPB_VAR_DEPRECATED,
    225         SerializedVarSendInput(dispatcher, object),
    226         argv_vect, &se, &result));
    227   }
    228   return result.Return(dispatcher);
    229 }
    230 
    231 bool IsInstanceOf(PP_Var var,
    232                   const PPP_Class_Deprecated* ppp_class,
    233                   void** ppp_class_data) {
    234   ProxyAutoLock lock;
    235   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, NULL);
    236   if (!dispatcher)
    237     return false;
    238 
    239   PP_Bool result = PP_FALSE;
    240   int64 class_int = static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class));
    241   int64 class_data_int = 0;
    242   dispatcher->Send(new PpapiHostMsg_PPBVar_IsInstanceOfDeprecated(
    243       API_ID_PPB_VAR_DEPRECATED, SerializedVarSendInput(dispatcher, var),
    244       class_int, &class_data_int, &result));
    245   *ppp_class_data =
    246       reinterpret_cast<void*>(static_cast<intptr_t>(class_data_int));
    247   return PP_ToBool(result);
    248 }
    249 
    250 PP_Var CreateObject(PP_Instance instance,
    251                     const PPP_Class_Deprecated* ppp_class,
    252                     void* ppp_class_data) {
    253   ProxyAutoLock lock;
    254   Dispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
    255   if (!dispatcher)
    256     return PP_MakeUndefined();
    257 
    258   PluginVarTracker* tracker = PluginGlobals::Get()->plugin_var_tracker();
    259   if (tracker->IsPluginImplementedObjectAlive(ppp_class_data))
    260     return PP_MakeUndefined();  // Object already exists with this user data.
    261 
    262   ReceiveSerializedVarReturnValue result;
    263   int64 class_int = static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class));
    264   int64 data_int =
    265       static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class_data));
    266   dispatcher->Send(new PpapiHostMsg_PPBVar_CreateObjectDeprecated(
    267       API_ID_PPB_VAR_DEPRECATED, instance, class_int, data_int,
    268       &result));
    269   PP_Var ret_var = result.Return(dispatcher);
    270 
    271   // Register this object as being implemented by the plugin.
    272   if (ret_var.type == PP_VARTYPE_OBJECT) {
    273     tracker->PluginImplementedObjectCreated(instance, ret_var,
    274                                             ppp_class, ppp_class_data);
    275   }
    276   return ret_var;
    277 }
    278 
    279 }  // namespace
    280 
    281 PPB_Var_Deprecated_Proxy::PPB_Var_Deprecated_Proxy(
    282     Dispatcher* dispatcher)
    283     : InterfaceProxy(dispatcher),
    284       ppb_var_impl_(NULL),
    285       task_factory_(this) {
    286   if (!dispatcher->IsPlugin()) {
    287     ppb_var_impl_ = static_cast<const PPB_Var_Deprecated*>(
    288         dispatcher->local_get_interface()(PPB_VAR_DEPRECATED_INTERFACE));
    289   }
    290 }
    291 
    292 PPB_Var_Deprecated_Proxy::~PPB_Var_Deprecated_Proxy() {
    293 }
    294 
    295 // static
    296 const PPB_Var_Deprecated* PPB_Var_Deprecated_Proxy::GetProxyInterface() {
    297   static const PPB_Var_Deprecated var_deprecated_interface = {
    298     ppapi::PPB_Var_Shared::GetVarInterface1_0()->AddRef,
    299     ppapi::PPB_Var_Shared::GetVarInterface1_0()->Release,
    300     ppapi::PPB_Var_Shared::GetVarInterface1_0()->VarFromUtf8,
    301     ppapi::PPB_Var_Shared::GetVarInterface1_0()->VarToUtf8,
    302     &HasProperty,
    303     &HasMethod,
    304     &GetProperty,
    305     &EnumerateProperties,
    306     &SetProperty,
    307     &RemoveProperty,
    308     &Call,
    309     &Construct,
    310     &IsInstanceOf,
    311     &CreateObject
    312   };
    313   return &var_deprecated_interface;
    314 }
    315 
    316 bool PPB_Var_Deprecated_Proxy::OnMessageReceived(const IPC::Message& msg) {
    317   if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
    318     return false;
    319 
    320   // Prevent the dispatcher from going away during a call to Call or other
    321   // function that could mutate the DOM. This must happen OUTSIDE of
    322   // the message handlers since the SerializedVars use the dispatcher upon
    323   // return of the function (converting the SerializedVarReturnValue/OutParam
    324   // to a SerializedVar in the destructor).
    325   ScopedModuleReference death_grip(dispatcher());
    326 
    327   bool handled = true;
    328   IPC_BEGIN_MESSAGE_MAP(PPB_Var_Deprecated_Proxy, msg)
    329     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_AddRefObject, OnMsgAddRefObject)
    330     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_ReleaseObject, OnMsgReleaseObject)
    331     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_HasProperty,
    332                         OnMsgHasProperty)
    333     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_HasMethodDeprecated,
    334                         OnMsgHasMethodDeprecated)
    335     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_GetProperty,
    336                         OnMsgGetProperty)
    337     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_DeleteProperty,
    338                         OnMsgDeleteProperty)
    339     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_EnumerateProperties,
    340                         OnMsgEnumerateProperties)
    341     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_SetPropertyDeprecated,
    342                         OnMsgSetPropertyDeprecated)
    343     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_CallDeprecated,
    344                         OnMsgCallDeprecated)
    345     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_Construct,
    346                         OnMsgConstruct)
    347     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_IsInstanceOfDeprecated,
    348                         OnMsgIsInstanceOfDeprecated)
    349     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_CreateObjectDeprecated,
    350                         OnMsgCreateObjectDeprecated)
    351     IPC_MESSAGE_UNHANDLED(handled = false)
    352   IPC_END_MESSAGE_MAP()
    353   // TODO(brettw) handle bad messages!
    354   return handled;
    355 }
    356 
    357 void PPB_Var_Deprecated_Proxy::OnMsgAddRefObject(int64 object_id) {
    358   PP_Var var = { PP_VARTYPE_OBJECT };
    359   var.value.as_id = object_id;
    360   ppb_var_impl_->AddRef(var);
    361 }
    362 
    363 void PPB_Var_Deprecated_Proxy::OnMsgReleaseObject(int64 object_id) {
    364   // Ok, so this is super subtle.
    365   // When the browser side sends a sync IPC message that returns a var, and the
    366   // plugin wants to give ownership of that var to the browser, dropping all
    367   // references, it may call ReleaseObject right after returning the result.
    368   // However, the IPC system doesn't enforce strict ordering of messages in that
    369   // case, where a message that is set to unblock (e.g. a sync message, or in
    370   // our case all messages coming from the plugin) that is sent *after* the
    371   // result may be dispatched on the browser side *before* the sync send
    372   // returned (see ipc_sync_channel.cc). In this case, that means it could
    373   // release the object before it is AddRef'ed on the browser side.
    374   // To work around this, we post a task here, that will not execute before
    375   // control goes back to the main message loop, that will ensure the sync send
    376   // has returned and the browser side can take its reference before we Release.
    377   // Note: if the instance is gone by the time the task is executed, then it
    378   // will Release the objects itself and this Release will be a NOOP (aside of a
    379   // spurious warning).
    380   // TODO(piman): See if we can fix the IPC code to enforce strict ordering, and
    381   // then remove this.
    382   base::MessageLoop::current()->PostNonNestableTask(
    383       FROM_HERE,
    384       RunWhileLocked(base::Bind(&PPB_Var_Deprecated_Proxy::DoReleaseObject,
    385                                 task_factory_.GetWeakPtr(),
    386                                 object_id)));
    387 }
    388 
    389 void PPB_Var_Deprecated_Proxy::OnMsgHasProperty(
    390     SerializedVarReceiveInput var,
    391     SerializedVarReceiveInput name,
    392     SerializedVarOutParam exception,
    393     PP_Bool* result) {
    394   SetAllowPluginReentrancy();
    395   *result = PP_FromBool(ppb_var_impl_->HasProperty(
    396       var.Get(dispatcher()),
    397       name.Get(dispatcher()),
    398       exception.OutParam(dispatcher())));
    399 }
    400 
    401 void PPB_Var_Deprecated_Proxy::OnMsgHasMethodDeprecated(
    402     SerializedVarReceiveInput var,
    403     SerializedVarReceiveInput name,
    404     SerializedVarOutParam exception,
    405     PP_Bool* result) {
    406   SetAllowPluginReentrancy();
    407   *result = PP_FromBool(ppb_var_impl_->HasMethod(
    408       var.Get(dispatcher()),
    409       name.Get(dispatcher()),
    410       exception.OutParam(dispatcher())));
    411 }
    412 
    413 void PPB_Var_Deprecated_Proxy::OnMsgGetProperty(
    414     SerializedVarReceiveInput var,
    415     SerializedVarReceiveInput name,
    416     SerializedVarOutParam exception,
    417     SerializedVarReturnValue result) {
    418   SetAllowPluginReentrancy();
    419   result.Return(dispatcher(), ppb_var_impl_->GetProperty(
    420       var.Get(dispatcher()), name.Get(dispatcher()),
    421       exception.OutParam(dispatcher())));
    422 }
    423 
    424 void PPB_Var_Deprecated_Proxy::OnMsgEnumerateProperties(
    425     SerializedVarReceiveInput var,
    426     SerializedVarVectorOutParam props,
    427     SerializedVarOutParam exception) {
    428   SetAllowPluginReentrancy();
    429   ppb_var_impl_->GetAllPropertyNames(var.Get(dispatcher()),
    430       props.CountOutParam(), props.ArrayOutParam(dispatcher()),
    431       exception.OutParam(dispatcher()));
    432 }
    433 
    434 void PPB_Var_Deprecated_Proxy::OnMsgSetPropertyDeprecated(
    435     SerializedVarReceiveInput var,
    436     SerializedVarReceiveInput name,
    437     SerializedVarReceiveInput value,
    438     SerializedVarOutParam exception) {
    439   SetAllowPluginReentrancy();
    440   ppb_var_impl_->SetProperty(var.Get(dispatcher()),
    441                                 name.Get(dispatcher()),
    442                                 value.Get(dispatcher()),
    443                                 exception.OutParam(dispatcher()));
    444 }
    445 
    446 void PPB_Var_Deprecated_Proxy::OnMsgDeleteProperty(
    447     SerializedVarReceiveInput var,
    448     SerializedVarReceiveInput name,
    449     SerializedVarOutParam exception,
    450     PP_Bool* result) {
    451   SetAllowPluginReentrancy();
    452   ppb_var_impl_->RemoveProperty(var.Get(dispatcher()),
    453                                    name.Get(dispatcher()),
    454                                    exception.OutParam(dispatcher()));
    455   // This deprecated function doesn't actually return a value, but we re-use
    456   // the message from the non-deprecated interface with the return value.
    457   *result = PP_TRUE;
    458 }
    459 
    460 void PPB_Var_Deprecated_Proxy::OnMsgCallDeprecated(
    461     SerializedVarReceiveInput object,
    462     SerializedVarReceiveInput method_name,
    463     SerializedVarVectorReceiveInput arg_vector,
    464     SerializedVarOutParam exception,
    465     SerializedVarReturnValue result) {
    466   SetAllowPluginReentrancy();
    467   uint32_t arg_count = 0;
    468   PP_Var* args = arg_vector.Get(dispatcher(), &arg_count);
    469   result.Return(dispatcher(), ppb_var_impl_->Call(
    470       object.Get(dispatcher()),
    471       method_name.Get(dispatcher()),
    472       arg_count, args,
    473       exception.OutParam(dispatcher())));
    474 }
    475 
    476 void PPB_Var_Deprecated_Proxy::OnMsgConstruct(
    477     SerializedVarReceiveInput var,
    478     SerializedVarVectorReceiveInput arg_vector,
    479     SerializedVarOutParam exception,
    480     SerializedVarReturnValue result) {
    481   SetAllowPluginReentrancy();
    482   uint32_t arg_count = 0;
    483   PP_Var* args = arg_vector.Get(dispatcher(), &arg_count);
    484   result.Return(dispatcher(), ppb_var_impl_->Construct(
    485       var.Get(dispatcher()), arg_count, args,
    486       exception.OutParam(dispatcher())));
    487 }
    488 
    489 void PPB_Var_Deprecated_Proxy::OnMsgIsInstanceOfDeprecated(
    490     SerializedVarReceiveInput var,
    491     int64 ppp_class,
    492     int64* ppp_class_data,
    493     PP_Bool* result) {
    494   SetAllowPluginReentrancy();
    495   *result = PPP_Class_Proxy::IsInstanceOf(ppb_var_impl_,
    496                                           var.Get(dispatcher()),
    497                                           ppp_class,
    498                                           ppp_class_data);
    499 }
    500 
    501 void PPB_Var_Deprecated_Proxy::OnMsgCreateObjectDeprecated(
    502     PP_Instance instance,
    503     int64 ppp_class,
    504     int64 class_data,
    505     SerializedVarReturnValue result) {
    506   SetAllowPluginReentrancy();
    507   result.Return(dispatcher(), PPP_Class_Proxy::CreateProxiedObject(
    508       ppb_var_impl_, dispatcher(), instance, ppp_class, class_data));
    509 }
    510 
    511 void PPB_Var_Deprecated_Proxy::SetAllowPluginReentrancy() {
    512   if (dispatcher()->IsPlugin())
    513     NOTREACHED();
    514   else
    515     static_cast<HostDispatcher*>(dispatcher())->set_allow_plugin_reentrancy();
    516 }
    517 
    518 void PPB_Var_Deprecated_Proxy::DoReleaseObject(int64 object_id) {
    519   PP_Var var = { PP_VARTYPE_OBJECT };
    520   var.value.as_id = object_id;
    521   ppb_var_impl_->Release(var);
    522 }
    523 
    524 }  // namespace proxy
    525 }  // namespace ppapi
    526