| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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_tcp_socket_proxy.h" | |
| 6 | |
| 7 #include <map> | |
| 8 | |
| 9 #include "base/logging.h" | |
| 10 #include "ppapi/proxy/plugin_dispatcher.h" | |
| 11 #include "ppapi/proxy/plugin_globals.h" | |
| 12 #include "ppapi/proxy/ppapi_messages.h" | |
| 13 #include "ppapi/shared_impl/resource.h" | |
| 14 #include "ppapi/shared_impl/socket_option_data.h" | |
| 15 #include "ppapi/shared_impl/tcp_socket_shared.h" | |
| 16 #include "ppapi/thunk/enter.h" | |
| 17 #include "ppapi/thunk/ppb_net_address_api.h" | |
| 18 #include "ppapi/thunk/ppb_tcp_socket_api.h" | |
| 19 #include "ppapi/thunk/thunk.h" | |
| 20 | |
| 21 namespace ppapi { | |
| 22 namespace proxy { | |
| 23 | |
| 24 namespace { | |
| 25 | |
| 26 typedef thunk::EnterResourceNoLock<thunk::PPB_NetAddress_API> | |
| 27 EnterNetAddressNoLock; | |
| 28 | |
| 29 typedef std::map<uint32, TCPSocketShared*> IDToSocketMap; | |
| 30 IDToSocketMap* g_id_to_socket = NULL; | |
| 31 | |
| 32 class TCPSocket : public thunk::PPB_TCPSocket_API, | |
| 33 public Resource, | |
| 34 public TCPSocketShared { | |
| 35 public: | |
| 36 TCPSocket(const HostResource& resource, uint32 socket_id); | |
| 37 virtual ~TCPSocket(); | |
| 38 | |
| 39 // Resource overrides. | |
| 40 virtual thunk::PPB_TCPSocket_API* AsPPB_TCPSocket_API() OVERRIDE; | |
| 41 | |
| 42 // thunk::PPB_TCPSocket_API implementation. | |
| 43 virtual int32_t Connect(PP_Resource addr, | |
| 44 scoped_refptr<TrackedCallback> callback) OVERRIDE; | |
| 45 virtual PP_Resource GetLocalAddress() OVERRIDE; | |
| 46 virtual PP_Resource GetRemoteAddress() OVERRIDE; | |
| 47 virtual int32_t Read(char* buffer, | |
| 48 int32_t bytes_to_read, | |
| 49 scoped_refptr<TrackedCallback> callback) OVERRIDE; | |
| 50 virtual int32_t Write(const char* buffer, | |
| 51 int32_t bytes_to_write, | |
| 52 scoped_refptr<TrackedCallback> callback) OVERRIDE; | |
| 53 virtual void Close() OVERRIDE; | |
| 54 virtual int32_t SetOption(PP_TCPSocket_Option name, | |
| 55 const PP_Var& value, | |
| 56 scoped_refptr<TrackedCallback> callback) OVERRIDE; | |
| 57 | |
| 58 // TCPSocketShared implementation. | |
| 59 virtual void SendConnect(const std::string& host, uint16_t port) OVERRIDE; | |
| 60 virtual void SendConnectWithNetAddress( | |
| 61 const PP_NetAddress_Private& addr) OVERRIDE; | |
| 62 virtual void SendSSLHandshake( | |
| 63 const std::string& server_name, | |
| 64 uint16_t server_port, | |
| 65 const std::vector<std::vector<char> >& trusted_certs, | |
| 66 const std::vector<std::vector<char> >& untrusted_certs) OVERRIDE; | |
| 67 virtual void SendRead(int32_t bytes_to_read) OVERRIDE; | |
| 68 virtual void SendWrite(const std::string& buffer) OVERRIDE; | |
| 69 virtual void SendDisconnect() OVERRIDE; | |
| 70 virtual void SendSetOption(PP_TCPSocket_Option name, | |
| 71 const SocketOptionData& value) OVERRIDE; | |
| 72 virtual Resource* GetOwnerResource() OVERRIDE; | |
| 73 | |
| 74 private: | |
| 75 void SendToBrowser(IPC::Message* msg); | |
| 76 | |
| 77 DISALLOW_COPY_AND_ASSIGN(TCPSocket); | |
| 78 }; | |
| 79 | |
| 80 TCPSocket::TCPSocket(const HostResource& resource, uint32 socket_id) | |
| 81 : Resource(OBJECT_IS_PROXY, resource), | |
| 82 TCPSocketShared(OBJECT_IS_PROXY, socket_id) { | |
| 83 if (!g_id_to_socket) | |
| 84 g_id_to_socket = new IDToSocketMap(); | |
| 85 DCHECK(g_id_to_socket->find(socket_id) == g_id_to_socket->end()); | |
| 86 (*g_id_to_socket)[socket_id] = this; | |
| 87 } | |
| 88 | |
| 89 TCPSocket::~TCPSocket() { | |
| 90 DisconnectImpl(); | |
| 91 } | |
| 92 | |
| 93 thunk::PPB_TCPSocket_API* TCPSocket::AsPPB_TCPSocket_API() { | |
| 94 return this; | |
| 95 } | |
| 96 | |
| 97 int32_t TCPSocket::Connect(PP_Resource addr, | |
| 98 scoped_refptr<TrackedCallback> callback) { | |
| 99 EnterNetAddressNoLock enter(addr, true); | |
| 100 if (enter.failed()) | |
| 101 return PP_ERROR_BADARGUMENT; | |
| 102 | |
| 103 return ConnectWithNetAddressImpl(&enter.object()->GetNetAddressPrivate(), | |
| 104 callback); | |
| 105 } | |
| 106 | |
| 107 PP_Resource TCPSocket::GetLocalAddress() { | |
| 108 PP_NetAddress_Private addr_private; | |
| 109 if (!GetLocalAddressImpl(&addr_private)) | |
| 110 return 0; | |
| 111 | |
| 112 thunk::EnterResourceCreationNoLock enter(pp_instance()); | |
| 113 if (enter.failed()) | |
| 114 return 0; | |
| 115 return enter.functions()->CreateNetAddressFromNetAddressPrivate( | |
| 116 pp_instance(), addr_private); | |
| 117 } | |
| 118 | |
| 119 PP_Resource TCPSocket::GetRemoteAddress() { | |
| 120 PP_NetAddress_Private addr_private; | |
| 121 if (!GetRemoteAddressImpl(&addr_private)) | |
| 122 return 0; | |
| 123 | |
| 124 thunk::EnterResourceCreationNoLock enter(pp_instance()); | |
| 125 if (enter.failed()) | |
| 126 return 0; | |
| 127 return enter.functions()->CreateNetAddressFromNetAddressPrivate( | |
| 128 pp_instance(), addr_private); | |
| 129 } | |
| 130 | |
| 131 int32_t TCPSocket::Read(char* buffer, | |
| 132 int32_t bytes_to_read, | |
| 133 scoped_refptr<TrackedCallback> callback) { | |
| 134 return ReadImpl(buffer, bytes_to_read, callback); | |
| 135 } | |
| 136 | |
| 137 int32_t TCPSocket::Write(const char* buffer, | |
| 138 int32_t bytes_to_write, | |
| 139 scoped_refptr<TrackedCallback> callback) { | |
| 140 return WriteImpl(buffer, bytes_to_write, callback); | |
| 141 } | |
| 142 | |
| 143 void TCPSocket::Close() { | |
| 144 DisconnectImpl(); | |
| 145 } | |
| 146 | |
| 147 int32_t TCPSocket::SetOption(PP_TCPSocket_Option name, | |
| 148 const PP_Var& value, | |
| 149 scoped_refptr<TrackedCallback> callback) { | |
| 150 return SetOptionImpl(name, value, callback); | |
| 151 } | |
| 152 | |
| 153 void TCPSocket::SendConnect(const std::string& host, uint16_t port) { | |
| 154 NOTREACHED(); | |
| 155 } | |
| 156 | |
| 157 void TCPSocket::SendConnectWithNetAddress(const PP_NetAddress_Private& addr) { | |
| 158 SendToBrowser(new PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress( | |
| 159 API_ID_PPB_TCPSOCKET, socket_id_, addr)); | |
| 160 } | |
| 161 | |
| 162 void TCPSocket::SendSSLHandshake( | |
| 163 const std::string& server_name, | |
| 164 uint16_t server_port, | |
| 165 const std::vector<std::vector<char> >& trusted_certs, | |
| 166 const std::vector<std::vector<char> >& untrusted_certs) { | |
| 167 NOTREACHED(); | |
| 168 } | |
| 169 | |
| 170 void TCPSocket::SendRead(int32_t bytes_to_read) { | |
| 171 SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Read(socket_id_, bytes_to_read)); | |
| 172 } | |
| 173 | |
| 174 void TCPSocket::SendWrite(const std::string& buffer) { | |
| 175 SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Write(socket_id_, buffer)); | |
| 176 } | |
| 177 | |
| 178 void TCPSocket::SendDisconnect() { | |
| 179 // After removed from the mapping, this object won't receive any notifications | |
| 180 // from the proxy. | |
| 181 DCHECK(g_id_to_socket->find(socket_id_) != g_id_to_socket->end()); | |
| 182 g_id_to_socket->erase(socket_id_); | |
| 183 SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Disconnect(socket_id_)); | |
| 184 } | |
| 185 | |
| 186 void TCPSocket::SendSetOption(PP_TCPSocket_Option name, | |
| 187 const SocketOptionData& value) { | |
| 188 SendToBrowser( | |
| 189 new PpapiHostMsg_PPBTCPSocket_SetOption(socket_id_, name, value)); | |
| 190 } | |
| 191 | |
| 192 Resource* TCPSocket::GetOwnerResource() { | |
| 193 return this; | |
| 194 } | |
| 195 | |
| 196 void TCPSocket::SendToBrowser(IPC::Message* msg) { | |
| 197 PluginGlobals::Get()->GetBrowserSender()->Send(msg); | |
| 198 } | |
| 199 | |
| 200 } // namespace | |
| 201 | |
| 202 //------------------------------------------------------------------------------ | |
| 203 | |
| 204 PPB_TCPSocket_Proxy::PPB_TCPSocket_Proxy(Dispatcher* dispatcher) | |
| 205 : InterfaceProxy(dispatcher) { | |
| 206 } | |
| 207 | |
| 208 PPB_TCPSocket_Proxy::~PPB_TCPSocket_Proxy() { | |
| 209 } | |
| 210 | |
| 211 // static | |
| 212 PP_Resource PPB_TCPSocket_Proxy::CreateProxyResource(PP_Instance instance) { | |
| 213 PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance); | |
| 214 if (!dispatcher) | |
| 215 return 0; | |
| 216 | |
| 217 uint32 socket_id = 0; | |
| 218 PluginGlobals::Get()->GetBrowserSender()->Send( | |
| 219 new PpapiHostMsg_PPBTCPSocket_Create( | |
| 220 API_ID_PPB_TCPSOCKET, dispatcher->plugin_dispatcher_id(), | |
| 221 &socket_id)); | |
| 222 if (socket_id == 0) | |
| 223 return 0; | |
| 224 return (new TCPSocket(HostResource::MakeInstanceOnly(instance), | |
| 225 socket_id))->GetReference(); | |
| 226 } | |
| 227 | |
| 228 bool PPB_TCPSocket_Proxy::OnMessageReceived(const IPC::Message& msg) { | |
| 229 bool handled = true; | |
| 230 IPC_BEGIN_MESSAGE_MAP(PPB_TCPSocket_Proxy, msg) | |
| 231 IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ConnectACK, | |
| 232 OnMsgConnectACK) | |
| 233 IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ReadACK, OnMsgReadACK) | |
| 234 IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_WriteACK, OnMsgWriteACK) | |
| 235 IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_SetOptionACK, | |
| 236 OnMsgSetOptionACK) | |
| 237 IPC_MESSAGE_UNHANDLED(handled = false) | |
| 238 IPC_END_MESSAGE_MAP() | |
| 239 return handled; | |
| 240 } | |
| 241 | |
| 242 void PPB_TCPSocket_Proxy::OnMsgConnectACK( | |
| 243 uint32 /* plugin_dispatcher_id */, | |
| 244 uint32 socket_id, | |
| 245 int32_t result, | |
| 246 const PP_NetAddress_Private& local_addr, | |
| 247 const PP_NetAddress_Private& remote_addr) { | |
| 248 if (!g_id_to_socket) { | |
| 249 NOTREACHED(); | |
| 250 return; | |
| 251 } | |
| 252 IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id); | |
| 253 if (iter == g_id_to_socket->end()) | |
| 254 return; | |
| 255 iter->second->OnConnectCompleted(result, local_addr, remote_addr); | |
| 256 } | |
| 257 | |
| 258 void PPB_TCPSocket_Proxy::OnMsgReadACK(uint32 /* plugin_dispatcher_id */, | |
| 259 uint32 socket_id, | |
| 260 int32_t result, | |
| 261 const std::string& data) { | |
| 262 if (!g_id_to_socket) { | |
| 263 NOTREACHED(); | |
| 264 return; | |
| 265 } | |
| 266 IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id); | |
| 267 if (iter == g_id_to_socket->end()) | |
| 268 return; | |
| 269 iter->second->OnReadCompleted(result, data); | |
| 270 } | |
| 271 | |
| 272 void PPB_TCPSocket_Proxy::OnMsgWriteACK(uint32 /* plugin_dispatcher_id */, | |
| 273 uint32 socket_id, | |
| 274 int32_t result) { | |
| 275 if (!g_id_to_socket) { | |
| 276 NOTREACHED(); | |
| 277 return; | |
| 278 } | |
| 279 IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id); | |
| 280 if (iter == g_id_to_socket->end()) | |
| 281 return; | |
| 282 iter->second->OnWriteCompleted(result); | |
| 283 } | |
| 284 | |
| 285 void PPB_TCPSocket_Proxy::OnMsgSetOptionACK(uint32 /* plugin_dispatcher_id */, | |
| 286 uint32 socket_id, | |
| 287 int32_t result) { | |
| 288 if (!g_id_to_socket) { | |
| 289 NOTREACHED(); | |
| 290 return; | |
| 291 } | |
| 292 IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id); | |
| 293 if (iter == g_id_to_socket->end()) | |
| 294 return; | |
| 295 iter->second->OnSetOptionCompleted(result); | |
| 296 } | |
| 297 | |
| 298 } // namespace proxy | |
| 299 } // namespace ppapi | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 22923014:
TCPSockets are switched to the new Pepper proxy. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src