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/serialized_var.h"
      6 
      7 #include "base/logging.h"
      8 #include "ipc/ipc_message_utils.h"
      9 #include "ppapi/c/pp_instance.h"
     10 #include "ppapi/proxy/dispatcher.h"
     11 #include "ppapi/proxy/interface_proxy.h"
     12 #include "ppapi/proxy/ppapi_param_traits.h"
     13 #include "ppapi/proxy/ppb_buffer_proxy.h"
     14 #include "ppapi/shared_impl/ppapi_globals.h"
     15 #include "ppapi/shared_impl/var.h"
     16 #include "ppapi/thunk/enter.h"
     17 
     18 namespace ppapi {
     19 namespace proxy {
     20 
     21 namespace {
     22 void DefaultHandleWriter(IPC::Message* m, const SerializedHandle& handle) {
     23   IPC::ParamTraits<SerializedHandle>::Write(m, handle);
     24 }
     25 }  // namespace
     26 
     27 // SerializedVar::Inner --------------------------------------------------------
     28 
     29 SerializedVar::Inner::Inner()
     30     : serialization_rules_(NULL),
     31       var_(PP_MakeUndefined()),
     32       instance_(0),
     33       cleanup_mode_(CLEANUP_NONE),
     34       is_valid_var_(true) {
     35 #ifndef NDEBUG
     36   has_been_serialized_ = false;
     37   has_been_deserialized_ = false;
     38 #endif
     39 }
     40 
     41 SerializedVar::Inner::Inner(VarSerializationRules* serialization_rules)
     42     : serialization_rules_(serialization_rules),
     43       var_(PP_MakeUndefined()),
     44       instance_(0),
     45       cleanup_mode_(CLEANUP_NONE) {
     46 #ifndef NDEBUG
     47   has_been_serialized_ = false;
     48   has_been_deserialized_ = false;
     49 #endif
     50 }
     51 
     52 SerializedVar::Inner::~Inner() {
     53   switch (cleanup_mode_) {
     54     case END_SEND_PASS_REF:
     55       serialization_rules_->EndSendPassRef(var_);
     56       break;
     57     case END_RECEIVE_CALLER_OWNED:
     58       serialization_rules_->EndReceiveCallerOwned(var_);
     59       break;
     60     default:
     61       break;
     62   }
     63 }
     64 
     65 PP_Var SerializedVar::Inner::GetVar() {
     66   DCHECK(serialization_rules_.get());
     67 
     68 #if defined(NACL_WIN64)
     69   NOTREACHED();
     70   return PP_MakeUndefined();
     71 #else
     72   if (raw_var_data_.get()) {
     73     var_ = raw_var_data_->CreatePPVar(instance_);
     74     raw_var_data_.reset(NULL);
     75   }
     76 
     77   return var_;
     78 #endif
     79 }
     80 
     81 void SerializedVar::Inner::SetVar(PP_Var var) {
     82   // Sanity check, when updating the var we should have received a
     83   // serialization rules pointer already.
     84   DCHECK(serialization_rules_.get());
     85   var_ = var;
     86   raw_var_data_.reset(NULL);
     87 }
     88 
     89 void SerializedVar::Inner::SetInstance(PP_Instance instance) {
     90   instance_ = instance;
     91 }
     92 
     93 void SerializedVar::Inner::ForceSetVarValueForTest(PP_Var value) {
     94   var_ = value;
     95   raw_var_data_.reset(NULL);
     96 }
     97 
     98 void SerializedVar::Inner::WriteToMessage(IPC::Message* m) const {
     99   // When writing to the IPC messages, a serialization rules handler should
    100   // always have been set.
    101   //
    102   // When sending a message, it should be difficult to trigger this if you're
    103   // using the SerializedVarSendInput class and giving a non-NULL dispatcher.
    104   // Make sure you're using the proper "Send" helper class.
    105   //
    106   // It should be more common to see this when handling an incoming message
    107   // that returns a var. This means the message handler didn't write to the
    108   // output parameter, or possibly you used the wrong helper class
    109   // (normally SerializedVarReturnValue).
    110   DCHECK(serialization_rules_.get());
    111 
    112 #ifndef NDEBUG
    113   // We should only be serializing something once.
    114   DCHECK(!has_been_serialized_);
    115   has_been_serialized_ = true;
    116 #endif
    117   scoped_ptr<RawVarDataGraph> data = RawVarDataGraph::Create(var_, instance_);
    118   if (data) {
    119     m->WriteBool(true);  // Success.
    120     data->Write(m, base::Bind(&DefaultHandleWriter));
    121   } else {
    122     m->WriteBool(false);  // Failure.
    123   }
    124 }
    125 
    126 void SerializedVar::Inner::WriteDataToMessage(
    127     IPC::Message* m,
    128     const HandleWriter& handle_writer) const {
    129   if (raw_var_data_) {
    130     m->WriteBool(true);  // Success.
    131     raw_var_data_->Write(m, handle_writer);
    132   } else {
    133     m->WriteBool(false);  // Failure.
    134   }
    135 }
    136 
    137 bool SerializedVar::Inner::ReadFromMessage(const IPC::Message* m,
    138                                            PickleIterator* iter) {
    139 #ifndef NDEBUG
    140   // We should only deserialize something once or will end up with leaked
    141   // references.
    142   //
    143   // One place this has happened in the past is using
    144   // std::vector<SerializedVar>.resize(). If you're doing this manually instead
    145   // of using the helper classes for handling in/out vectors of vars, be
    146   // sure you use the same pattern as the SerializedVarVector classes.
    147   DCHECK(!has_been_deserialized_);
    148   has_been_deserialized_ = true;
    149 #endif
    150   // When reading, the dispatcher should be set when we get a Deserialize
    151   // call (which will supply a dispatcher).
    152   if (!m->ReadBool(iter, &is_valid_var_))
    153       return false;
    154   if (is_valid_var_) {
    155     raw_var_data_ = RawVarDataGraph::Read(m, iter);
    156     if (!raw_var_data_)
    157       return false;
    158   }
    159 
    160   return true;
    161 }
    162 
    163 void SerializedVar::Inner::SetCleanupModeToEndSendPassRef() {
    164   cleanup_mode_ = END_SEND_PASS_REF;
    165 }
    166 
    167 void SerializedVar::Inner::SetCleanupModeToEndReceiveCallerOwned() {
    168   cleanup_mode_ = END_RECEIVE_CALLER_OWNED;
    169 }
    170 
    171 // SerializedVar ---------------------------------------------------------------
    172 
    173 SerializedVar::SerializedVar() : inner_(new Inner) {
    174 }
    175 
    176 SerializedVar::SerializedVar(VarSerializationRules* serialization_rules)
    177     : inner_(new Inner(serialization_rules)) {
    178 }
    179 
    180 SerializedVar::~SerializedVar() {
    181 }
    182 
    183 // SerializedVarSendInput ------------------------------------------------------
    184 
    185 SerializedVarSendInput::SerializedVarSendInput(Dispatcher* dispatcher,
    186                                                const PP_Var& var)
    187     : SerializedVar(dispatcher->serialization_rules()) {
    188   inner_->SetVar(dispatcher->serialization_rules()->SendCallerOwned(var));
    189 }
    190 
    191 // static
    192 void SerializedVarSendInput::ConvertVector(Dispatcher* dispatcher,
    193                                            const PP_Var* input,
    194                                            size_t input_count,
    195                                            std::vector<SerializedVar>* output) {
    196   output->reserve(input_count);
    197   for (size_t i = 0; i < input_count; i++)
    198     output->push_back(SerializedVarSendInput(dispatcher, input[i]));
    199 }
    200 
    201 // SerializedVarSendInputShmem -------------------------------------------------
    202 
    203 SerializedVarSendInputShmem::SerializedVarSendInputShmem(
    204     Dispatcher* dispatcher,
    205     const PP_Var& var,
    206     const PP_Instance& instance)
    207     : SerializedVar(dispatcher->serialization_rules()) {
    208   inner_->SetVar(dispatcher->serialization_rules()->SendCallerOwned(var));
    209   inner_->SetInstance(instance);
    210 }
    211 
    212 // ReceiveSerializedVarReturnValue ---------------------------------------------
    213 
    214 ReceiveSerializedVarReturnValue::ReceiveSerializedVarReturnValue() {
    215 }
    216 
    217 ReceiveSerializedVarReturnValue::ReceiveSerializedVarReturnValue(
    218     const SerializedVar& serialized)
    219     : SerializedVar(serialized) {
    220 }
    221 
    222 PP_Var ReceiveSerializedVarReturnValue::Return(Dispatcher* dispatcher) {
    223   inner_->set_serialization_rules(dispatcher->serialization_rules());
    224   inner_->SetVar(inner_->serialization_rules()->ReceivePassRef(
    225       inner_->GetVar()));
    226   return inner_->GetVar();
    227 }
    228 
    229 // ReceiveSerializedException --------------------------------------------------
    230 
    231 ReceiveSerializedException::ReceiveSerializedException(Dispatcher* dispatcher,
    232                                                        PP_Var* exception)
    233     : SerializedVar(dispatcher->serialization_rules()),
    234       exception_(exception) {
    235 }
    236 
    237 ReceiveSerializedException::~ReceiveSerializedException() {
    238   if (exception_) {
    239     // When an output exception is specified, it will take ownership of the
    240     // reference.
    241     inner_->SetVar(
    242         inner_->serialization_rules()->ReceivePassRef(inner_->GetVar()));
    243     *exception_ = inner_->GetVar();
    244   } else {
    245     // When no output exception is specified, the browser thinks we have a ref
    246     // to an object that we don't want (this will happen only in the plugin
    247     // since the browser will always specify an out exception for the plugin to
    248     // write into).
    249     //
    250     // Strings don't need this handling since we can just avoid creating a
    251     // Var from the std::string in the first place.
    252     if (inner_->GetVar().type == PP_VARTYPE_OBJECT)
    253       inner_->serialization_rules()->ReleaseObjectRef(inner_->GetVar());
    254   }
    255 }
    256 
    257 bool ReceiveSerializedException::IsThrown() const {
    258   return exception_ && exception_->type != PP_VARTYPE_UNDEFINED;
    259 }
    260 
    261 // ReceiveSerializedVarVectorOutParam ------------------------------------------
    262 
    263 ReceiveSerializedVarVectorOutParam::ReceiveSerializedVarVectorOutParam(
    264     Dispatcher* dispatcher,
    265     uint32_t* output_count,
    266     PP_Var** output)
    267     : dispatcher_(dispatcher),
    268       output_count_(output_count),
    269       output_(output) {
    270 }
    271 
    272 ReceiveSerializedVarVectorOutParam::~ReceiveSerializedVarVectorOutParam() {
    273   *output_count_ = static_cast<uint32_t>(vector_.size());
    274   if (!vector_.size()) {
    275     *output_ = NULL;
    276     return;
    277   }
    278 
    279   *output_ = static_cast<PP_Var*>(malloc(vector_.size() * sizeof(PP_Var)));
    280   for (size_t i = 0; i < vector_.size(); i++) {
    281     // Here we just mimic what happens when returning a value.
    282     ReceiveSerializedVarReturnValue converted;
    283     SerializedVar* serialized = &converted;
    284     *serialized = vector_[i];
    285     (*output_)[i] = converted.Return(dispatcher_);
    286   }
    287 }
    288 
    289 std::vector<SerializedVar>* ReceiveSerializedVarVectorOutParam::OutParam() {
    290   return &vector_;
    291 }
    292 
    293 // SerializedVarReceiveInput ---------------------------------------------------
    294 
    295 SerializedVarReceiveInput::SerializedVarReceiveInput(
    296     const SerializedVar& serialized)
    297     : serialized_(serialized) {
    298 }
    299 
    300 SerializedVarReceiveInput::~SerializedVarReceiveInput() {
    301 }
    302 
    303 PP_Var SerializedVarReceiveInput::Get(Dispatcher* dispatcher) {
    304   serialized_.inner_->set_serialization_rules(
    305       dispatcher->serialization_rules());
    306 
    307   // Ensure that when the serialized var goes out of scope it cleans up the
    308   // stuff we're making in BeginReceiveCallerOwned.
    309   serialized_.inner_->SetCleanupModeToEndReceiveCallerOwned();
    310 
    311   serialized_.inner_->SetVar(
    312       serialized_.inner_->serialization_rules()->BeginReceiveCallerOwned(
    313           serialized_.inner_->GetVar()));
    314   return serialized_.inner_->GetVar();
    315 }
    316 
    317 
    318 PP_Var SerializedVarReceiveInput::GetForInstance(Dispatcher* dispatcher,
    319                                                  PP_Instance instance) {
    320   serialized_.inner_->SetInstance(instance);
    321   return Get(dispatcher);
    322 }
    323 
    324 // SerializedVarVectorReceiveInput ---------------------------------------------
    325 
    326 SerializedVarVectorReceiveInput::SerializedVarVectorReceiveInput(
    327     const std::vector<SerializedVar>& serialized)
    328     : serialized_(serialized) {
    329 }
    330 
    331 SerializedVarVectorReceiveInput::~SerializedVarVectorReceiveInput() {
    332   for (size_t i = 0; i < deserialized_.size(); i++) {
    333     serialized_[i].inner_->serialization_rules()->EndReceiveCallerOwned(
    334         deserialized_[i]);
    335   }
    336 }
    337 
    338 PP_Var* SerializedVarVectorReceiveInput::Get(Dispatcher* dispatcher,
    339                                              uint32_t* array_size) {
    340   deserialized_.resize(serialized_.size());
    341   for (size_t i = 0; i < serialized_.size(); i++) {
    342     // The vectors must be able to clean themselves up after this call is
    343     // torn down.
    344     serialized_[i].inner_->set_serialization_rules(
    345         dispatcher->serialization_rules());
    346 
    347     serialized_[i].inner_->SetVar(
    348         serialized_[i].inner_->serialization_rules()->BeginReceiveCallerOwned(
    349             serialized_[i].inner_->GetVar()));
    350     deserialized_[i] = serialized_[i].inner_->GetVar();
    351   }
    352 
    353   *array_size = static_cast<uint32_t>(serialized_.size());
    354   return deserialized_.empty() ? NULL : &deserialized_[0];
    355 }
    356 
    357 // SerializedVarReturnValue ----------------------------------------------------
    358 
    359 SerializedVarReturnValue::SerializedVarReturnValue(SerializedVar* serialized)
    360     : serialized_(serialized) {
    361 }
    362 
    363 void SerializedVarReturnValue::Return(Dispatcher* dispatcher,
    364                                       const PP_Var& var) {
    365   serialized_->inner_->set_serialization_rules(
    366       dispatcher->serialization_rules());
    367 
    368   // Var must clean up after our BeginSendPassRef call.
    369   serialized_->inner_->SetCleanupModeToEndSendPassRef();
    370 
    371   serialized_->inner_->SetVar(
    372       dispatcher->serialization_rules()->BeginSendPassRef(var));
    373 }
    374 
    375 // static
    376 SerializedVar SerializedVarReturnValue::Convert(Dispatcher* dispatcher,
    377                                                 const PP_Var& var) {
    378   // Mimic what happens in the normal case.
    379   SerializedVar result;
    380   SerializedVarReturnValue retvalue(&result);
    381   retvalue.Return(dispatcher, var);
    382   return result;
    383 }
    384 
    385 // SerializedVarOutParam -------------------------------------------------------
    386 
    387 SerializedVarOutParam::SerializedVarOutParam(SerializedVar* serialized)
    388     : serialized_(serialized),
    389       writable_var_(PP_MakeUndefined()),
    390       dispatcher_(NULL) {
    391 }
    392 
    393 SerializedVarOutParam::~SerializedVarOutParam() {
    394   if (serialized_->inner_->serialization_rules()) {
    395     // When unset, OutParam wasn't called. We'll just leave the var untouched
    396     // in that case.
    397     serialized_->inner_->SetVar(
    398         serialized_->inner_->serialization_rules()->BeginSendPassRef(
    399             writable_var_));
    400 
    401     // Normally the current object will be created on the stack to wrap a
    402     // SerializedVar and won't have a scope around the actual IPC send. So we
    403     // need to tell the SerializedVar to do the begin/end send pass ref calls.
    404     serialized_->inner_->SetCleanupModeToEndSendPassRef();
    405   }
    406 }
    407 
    408 PP_Var* SerializedVarOutParam::OutParam(Dispatcher* dispatcher) {
    409   dispatcher_ = dispatcher;
    410   serialized_->inner_->set_serialization_rules(
    411       dispatcher->serialization_rules());
    412   return &writable_var_;
    413 }
    414 
    415 // SerializedVarVectorOutParam -------------------------------------------------
    416 
    417 SerializedVarVectorOutParam::SerializedVarVectorOutParam(
    418     std::vector<SerializedVar>* serialized)
    419     : dispatcher_(NULL),
    420       serialized_(serialized),
    421       count_(0),
    422       array_(NULL) {
    423 }
    424 
    425 SerializedVarVectorOutParam::~SerializedVarVectorOutParam() {
    426   DCHECK(dispatcher_);
    427 
    428   // Convert the array written by the pepper code to the serialized structure.
    429   // Note we can't use resize here, we have to allocate a new SerializedVar
    430   // for each serialized item. See ParamTraits<vector<SerializedVar>>::Read.
    431   serialized_->reserve(count_);
    432   for (uint32_t i = 0; i < count_; i++) {
    433     // Just mimic what we do for regular OutParams.
    434     SerializedVar var;
    435     SerializedVarOutParam out(&var);
    436     *out.OutParam(dispatcher_) = array_[i];
    437     serialized_->push_back(var);
    438   }
    439 
    440   // When returning arrays, the pepper code expects the caller to take
    441   // ownership of the array.
    442   free(array_);
    443 }
    444 
    445 PP_Var** SerializedVarVectorOutParam::ArrayOutParam(Dispatcher* dispatcher) {
    446   DCHECK(!dispatcher_);  // Should only be called once.
    447   dispatcher_ = dispatcher;
    448   return &array_;
    449 }
    450 
    451 SerializedVarTestConstructor::SerializedVarTestConstructor(
    452     const PP_Var& pod_var) {
    453   DCHECK(pod_var.type != PP_VARTYPE_STRING);
    454   inner_->ForceSetVarValueForTest(pod_var);
    455 }
    456 
    457 SerializedVarTestConstructor::SerializedVarTestConstructor(
    458     const std::string& str) {
    459   inner_->ForceSetVarValueForTest(StringVar::StringToPPVar(str));
    460 }
    461 
    462 SerializedVarTestReader::SerializedVarTestReader(const SerializedVar& var)
    463     : SerializedVar(var) {
    464 }
    465 
    466 }  // namespace proxy
    467 }  // namespace ppapi
    468