ppapi/proxy/resource_message_params.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/resource_message_params.h"
   6
   7 #include "base/logging.h"
   8 #include "ppapi/c/pp_errors.h"
   9 #include "ppapi/proxy/ppapi_messages.h"
  10
  11 namespace ppapi {
  12 namespace proxy {
  13
  14 ResourceMessageParams::SerializedHandles::SerializedHandles()
  15     : should_close_(false) {
  16 }
  17
  18 ResourceMessageParams::SerializedHandles::~SerializedHandles() {
  19   if (should_close_) {
  20     for (std::vector<SerializedHandle>::iterator iter = data_.begin();
  21          iter != data_.end(); ++iter) {
  22       iter->Close();
  23     }
  24   }
  25 }
  26
  27 ResourceMessageParams::ResourceMessageParams()
  28     : pp_resource_(0),
  29       sequence_(0),
  30       handles_(new SerializedHandles()) {
  31 }
  32
  33 ResourceMessageParams::ResourceMessageParams(PP_Resource resource,
  34                                              int32_t sequence)
  35     : pp_resource_(resource),
  36       sequence_(sequence),
  37       handles_(new SerializedHandles()) {
  38 }
  39
  40 ResourceMessageParams::~ResourceMessageParams() {
  41 }
  42
  43 void ResourceMessageParams::Serialize(IPC::Message* msg) const {
  44   IPC::ParamTraits<PP_Resource>::Write(msg, pp_resource_);
  45   IPC::ParamTraits<int32_t>::Write(msg, sequence_);
  46   IPC::ParamTraits<std::vector<SerializedHandle> >::Write(msg,
  47                                                           handles_->data());
  48 }
  49
  50 bool ResourceMessageParams::Deserialize(const IPC::Message* msg,
  51                                         PickleIterator* iter) {
  52   DCHECK(handles_->data().empty());
  53   handles_->set_should_close(true);
  54   return IPC::ParamTraits<PP_Resource>::Read(msg, iter, &pp_resource_) &&
  55          IPC::ParamTraits<int32_t>::Read(msg, iter, &sequence_) &&
  56          IPC::ParamTraits<std::vector<SerializedHandle> >::Read(
  57              msg, iter, &handles_->data());
  58 }
  59
  60 SerializedHandle ResourceMessageParams::TakeHandleOfTypeAtIndex(
  61     size_t index,
  62     SerializedHandle::Type type) const {
  63   SerializedHandle handle;
  64   std::vector<SerializedHandle>& data = handles_->data();
  65   if (index < data.size() && data[index].type() == type) {
  66     handle = data[index];
  67     data[index] = SerializedHandle();
  68   }
  69   return handle;
  70 }
  71
  72 bool ResourceMessageParams::TakeSharedMemoryHandleAtIndex(
  73     size_t index,
  74     base::SharedMemoryHandle* handle) const {
  75   SerializedHandle serialized = TakeHandleOfTypeAtIndex(
  76       index, SerializedHandle::SHARED_MEMORY);
  77   if (!serialized.is_shmem())
  78     return false;
  79   *handle = serialized.shmem();
  80   return true;
  81 }
  82
  83 bool ResourceMessageParams::TakeSocketHandleAtIndex(
  84     size_t index,
  85     IPC::PlatformFileForTransit* handle) const {
  86   SerializedHandle serialized = TakeHandleOfTypeAtIndex(
  87       index, SerializedHandle::SOCKET);
  88   if (!serialized.is_socket())
  89     return false;
  90   *handle = serialized.descriptor();
  91   return true;
  92 }
  93
  94 void ResourceMessageParams::TakeAllSharedMemoryHandles(
  95     std::vector<base::SharedMemoryHandle>* handles) const {
  96   for (size_t i = 0; i < handles_->data().size(); ++i) {
  97     base::SharedMemoryHandle handle;
  98     if (TakeSharedMemoryHandleAtIndex(i, &handle))
  99       handles->push_back(handle);
 100   }
 101 }
 102
 103 void ResourceMessageParams::AppendHandle(const SerializedHandle& handle) const {
 104   handles_->data().push_back(handle);
 105 }
 106
 107 ResourceMessageCallParams::ResourceMessageCallParams()
 108     : ResourceMessageParams(),
 109       has_callback_(0) {
 110 }
 111
 112 ResourceMessageCallParams::ResourceMessageCallParams(PP_Resource resource,
 113                                                      int32_t sequence)
 114     : ResourceMessageParams(resource, sequence),
 115       has_callback_(0) {
 116 }
 117
 118 ResourceMessageCallParams::~ResourceMessageCallParams() {
 119 }
 120
 121 void ResourceMessageCallParams::Serialize(IPC::Message* msg) const {
 122   ResourceMessageParams::Serialize(msg);
 123   IPC::ParamTraits<bool>::Write(msg, has_callback_);
 124 }
 125
 126 bool ResourceMessageCallParams::Deserialize(const IPC::Message* msg,
 127                                             PickleIterator* iter) {
 128   if (!ResourceMessageParams::Deserialize(msg, iter))
 129     return false;
 130   return IPC::ParamTraits<bool>::Read(msg, iter, &has_callback_);
 131 }
 132
 133 ResourceMessageReplyParams::ResourceMessageReplyParams()
 134     : ResourceMessageParams(),
 135       result_(PP_OK) {
 136 }
 137
 138 ResourceMessageReplyParams::ResourceMessageReplyParams(PP_Resource resource,
 139                                                        int32_t sequence)
 140     : ResourceMessageParams(resource, sequence),
 141       result_(PP_OK) {
 142 }
 143
 144 ResourceMessageReplyParams::~ResourceMessageReplyParams() {
 145 }
 146
 147 void ResourceMessageReplyParams::Serialize(IPC::Message* msg) const {
 148   ResourceMessageParams::Serialize(msg);
 149   IPC::ParamTraits<int32_t>::Write(msg, result_);
 150 }
 151
 152 bool ResourceMessageReplyParams::Deserialize(const IPC::Message* msg,
 153                                              PickleIterator* iter) {
 154   if (!ResourceMessageParams::Deserialize(msg, iter))
 155     return false;
 156   return IPC::ParamTraits<int32_t>::Read(msg, iter, &result_);
 157 }
 158
 159 }  // namespace proxy
 160 }  // namespace ppapi