ppapi/proxy/ppb_broker_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/ppb_broker_proxy.h"
   6
   7 #include "base/bind.h"
   8 #include "ppapi/c/pp_errors.h"
   9 #include "ppapi/c/trusted/ppb_broker_trusted.h"
  10 #include "ppapi/proxy/enter_proxy.h"
  11 #include "ppapi/proxy/plugin_dispatcher.h"
  12 #include "ppapi/proxy/ppapi_messages.h"
  13 #include "ppapi/shared_impl/platform_file.h"
  14 #include "ppapi/shared_impl/tracked_callback.h"
  15 #include "ppapi/thunk/ppb_broker_api.h"
  16 #include "ppapi/thunk/enter.h"
  17 #include "ppapi/thunk/resource_creation_api.h"
  18 #include "ppapi/thunk/thunk.h"
  19
  20 using ppapi::IntToPlatformFile;
  21 using ppapi::PlatformFileToInt;
  22 using ppapi::thunk::PPB_Broker_API;
  23
  24 namespace ppapi {
  25 namespace proxy {
  26
  27 class Broker : public PPB_Broker_API, public Resource {
  28  public:
  29   explicit Broker(const HostResource& resource);
  30   virtual ~Broker();
  31
  32   // Resource overrides.
  33   virtual PPB_Broker_API* AsPPB_Broker_API() OVERRIDE;
  34
  35   // PPB_Broker_API implementation.
  36   virtual int32_t Connect(
  37       scoped_refptr<TrackedCallback> connect_callback) OVERRIDE;
  38   virtual int32_t GetHandle(int32_t* handle) OVERRIDE;
  39
  40   // Called by the proxy when the host side has completed the request.
  41   void ConnectComplete(IPC::PlatformFileForTransit socket_handle,
  42                        int32_t result);
  43
  44  private:
  45   bool called_connect_;
  46   scoped_refptr<TrackedCallback> current_connect_callback_;
  47
  48   // The plugin module owns the handle.
  49   // The host side transfers ownership of the handle to the plugin side when it
  50   // sends the IPC. This member holds the handle value for the plugin module
  51   // to read, but the plugin side of the proxy never takes ownership.
  52   base::SyncSocket::Handle socket_handle_;
  53
  54   DISALLOW_COPY_AND_ASSIGN(Broker);
  55 };
  56
  57 Broker::Broker(const HostResource& resource)
  58     : Resource(OBJECT_IS_PROXY, resource),
  59       called_connect_(false),
  60       socket_handle_(base::SyncSocket::kInvalidHandle) {
  61 }
  62
  63 Broker::~Broker() {
  64   socket_handle_ = base::SyncSocket::kInvalidHandle;
  65 }
  66
  67 PPB_Broker_API* Broker::AsPPB_Broker_API() {
  68   return this;
  69 }
  70
  71 int32_t Broker::Connect(scoped_refptr<TrackedCallback> connect_callback) {
  72   if (TrackedCallback::IsPending(current_connect_callback_))
  73     return PP_ERROR_INPROGRESS;
  74   else if (called_connect_)
  75     return PP_ERROR_FAILED;
  76
  77   current_connect_callback_ = connect_callback;
  78   called_connect_ = true;
  79
  80   bool success = PluginDispatcher::GetForResource(this)->Send(
  81       new PpapiHostMsg_PPBBroker_Connect(
  82           API_ID_PPB_BROKER, host_resource()));
  83   return success ?  PP_OK_COMPLETIONPENDING : PP_ERROR_FAILED;
  84 }
  85
  86 int32_t Broker::GetHandle(int32_t* handle) {
  87   if (socket_handle_ == base::SyncSocket::kInvalidHandle)
  88     return PP_ERROR_FAILED;
  89   *handle = PlatformFileToInt(socket_handle_);
  90   return PP_OK;
  91 }
  92
  93 void Broker::ConnectComplete(IPC::PlatformFileForTransit socket_handle,
  94                              int32_t result) {
  95   if (result == PP_OK) {
  96     DCHECK(socket_handle_ == base::SyncSocket::kInvalidHandle);
  97     socket_handle_ = IPC::PlatformFileForTransitToPlatformFile(socket_handle);
  98   } else {
  99     // The caller may still have given us a handle in the failure case.
 100     // The easiest way to clean it up is to just put it in an object
 101     // and then close them. This failure case is not performance critical.
 102     base::SyncSocket temp_socket(
 103         IPC::PlatformFileForTransitToPlatformFile(socket_handle));
 104   }
 105
 106   if (!TrackedCallback::IsPending(current_connect_callback_)) {
 107     // The handle might leak if the plugin never calls GetHandle().
 108     return;
 109   }
 110
 111   current_connect_callback_->Run(result);
 112 }
 113
 114 PPB_Broker_Proxy::PPB_Broker_Proxy(Dispatcher* dispatcher)
 115     : InterfaceProxy(dispatcher),
 116       callback_factory_(this){
 117 }
 118
 119 PPB_Broker_Proxy::~PPB_Broker_Proxy() {
 120 }
 121
 122 // static
 123 PP_Resource PPB_Broker_Proxy::CreateProxyResource(PP_Instance instance) {
 124   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
 125   if (!dispatcher)
 126     return 0;
 127
 128   HostResource result;
 129   dispatcher->Send(new PpapiHostMsg_PPBBroker_Create(
 130       API_ID_PPB_BROKER, instance, &result));
 131   if (result.is_null())
 132     return 0;
 133   return (new Broker(result))->GetReference();
 134 }
 135
 136 bool PPB_Broker_Proxy::OnMessageReceived(const IPC::Message& msg) {
 137   bool handled = true;
 138   IPC_BEGIN_MESSAGE_MAP(PPB_Broker_Proxy, msg)
 139     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBBroker_Create, OnMsgCreate)
 140     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBBroker_Connect, OnMsgConnect)
 141     IPC_MESSAGE_HANDLER(PpapiMsg_PPBBroker_ConnectComplete,
 142                         OnMsgConnectComplete)
 143     IPC_MESSAGE_UNHANDLED(handled = false)
 144   IPC_END_MESSAGE_MAP()
 145   return handled;
 146 }
 147
 148 void PPB_Broker_Proxy::OnMsgCreate(PP_Instance instance,
 149                                    HostResource* result_resource) {
 150   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
 151     return;
 152   thunk::EnterResourceCreation enter(instance);
 153   if (enter.succeeded()) {
 154     result_resource->SetHostResource(
 155         instance,
 156         enter.functions()->CreateBroker(instance));
 157   }
 158 }
 159
 160 void PPB_Broker_Proxy::OnMsgConnect(const HostResource& broker) {
 161   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
 162     return;
 163   EnterHostFromHostResourceForceCallback<PPB_Broker_API> enter(
 164       broker, callback_factory_,
 165       &PPB_Broker_Proxy::ConnectCompleteInHost, broker);
 166   if (enter.succeeded())
 167     enter.SetResult(enter.object()->Connect(enter.callback()));
 168 }
 169
 170 // Called in the plugin to handle the connect callback.
 171 // The proxy owns the handle and transfers it to the Broker. At that point,
 172 // the plugin owns the handle and is responsible for closing it.
 173 // The caller guarantees that socket_handle is not valid if result is not PP_OK.
 174 void PPB_Broker_Proxy::OnMsgConnectComplete(
 175     const HostResource& resource,
 176     IPC::PlatformFileForTransit socket_handle,
 177     int32_t result) {
 178   DCHECK(result == PP_OK ||
 179          socket_handle == IPC::InvalidPlatformFileForTransit());
 180
 181   EnterPluginFromHostResource<PPB_Broker_API> enter(resource);
 182   if (enter.failed()) {
 183     // As in Broker::ConnectComplete, we need to close the resource on error.
 184     base::SyncSocket temp_socket(
 185         IPC::PlatformFileForTransitToPlatformFile(socket_handle));
 186   } else {
 187     static_cast<Broker*>(enter.object())->ConnectComplete(socket_handle,
 188                                                           result);
 189   }
 190 }
 191
 192 // Callback on the host side.
 193 // Transfers ownership of the handle to the plugin side. This function must
 194 // either successfully call the callback or close the handle.
 195 void PPB_Broker_Proxy::ConnectCompleteInHost(int32_t result,
 196                                              const HostResource& broker) {
 197   IPC::PlatformFileForTransit foreign_socket_handle =
 198       IPC::InvalidPlatformFileForTransit();
 199   if (result == PP_OK) {
 200     int32_t socket_handle = PlatformFileToInt(base::SyncSocket::kInvalidHandle);
 201     EnterHostFromHostResource<PPB_Broker_API> enter(broker);
 202     if (enter.succeeded())
 203       result = enter.object()->GetHandle(&socket_handle);
 204     DCHECK(result == PP_OK ||
 205            socket_handle ==
 206                PlatformFileToInt(base::SyncSocket::kInvalidHandle));
 207
 208     if (result == PP_OK) {
 209       foreign_socket_handle =
 210           dispatcher()->ShareHandleWithRemote(IntToPlatformFile(socket_handle),
 211                                               true);
 212       if (foreign_socket_handle == IPC::InvalidPlatformFileForTransit()) {
 213         result = PP_ERROR_FAILED;
 214         // Assume the local handle was closed even if the foreign handle could
 215         // not be created.
 216       }
 217     }
 218   }
 219   DCHECK(result == PP_OK ||
 220          foreign_socket_handle == IPC::InvalidPlatformFileForTransit());
 221
 222   bool success = dispatcher()->Send(new PpapiMsg_PPBBroker_ConnectComplete(
 223       API_ID_PPB_BROKER, broker, foreign_socket_handle, result));
 224
 225   if (!success || result != PP_OK) {
 226       // The plugin did not receive the handle, so it must be closed.
 227       // The easiest way to clean it up is to just put it in an object
 228       // and then close it. This failure case is not performance critical.
 229       // The handle could still leak if Send succeeded but the IPC later failed.
 230       base::SyncSocket temp_socket(
 231           IPC::PlatformFileForTransitToPlatformFile(foreign_socket_handle));
 232   }
 233 }
 234
 235 }  // namespace proxy
 236 }  // namespace ppapi