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