Chromium Code Reviews
[email protected] (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(48)

Side by Side Diff: ppapi/proxy/ppb_tcp_socket_proxy.cc

Issue 16667002: Introduce PPB_TCPSocket_Dev. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: . Created 7 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « ppapi/proxy/ppb_tcp_socket_proxy.h ('k') | ppapi/proxy/resource_creation_proxy.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
OLDNEW
« no previous file with comments | « ppapi/proxy/ppb_tcp_socket_proxy.h ('k') | ppapi/proxy/resource_creation_proxy.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698