diff options
Diffstat (limited to 'ppapi')
| -rw-r--r-- | ppapi/ppapi_shared.gypi | 5 | ||||
| -rw-r--r-- | ppapi/ppapi_sources.gypi | 6 | ||||
| -rw-r--r-- | ppapi/proxy/ppb_tcp_socket_private_proxy.cc | 353 | ||||
| -rw-r--r-- | ppapi/proxy/ppb_tcp_socket_private_proxy.h | 7 | ||||
| -rw-r--r-- | ppapi/proxy/ppb_udp_socket_private_proxy.cc | 243 | ||||
| -rw-r--r-- | ppapi/proxy/ppb_udp_socket_private_proxy.h | 8 | ||||
| -rw-r--r-- | ppapi/shared_impl/private/tcp_socket_private_impl.cc | 289 | ||||
| -rw-r--r-- | ppapi/shared_impl/private/tcp_socket_private_impl.h | 116 | ||||
| -rw-r--r-- | ppapi/shared_impl/private/udp_socket_private_impl.cc | 209 | ||||
| -rw-r--r-- | ppapi/shared_impl/private/udp_socket_private_impl.h | 92 | ||||
| -rw-r--r-- | ppapi/tests/test_tcp_socket_private_shared.cc | 271 | ||||
| -rw-r--r-- | ppapi/tests/test_tcp_socket_private_shared.h | 49 | ||||
| -rw-r--r-- | ppapi/tests/test_udp_socket_private_shared.cc | 182 | ||||
| -rw-r--r-- | ppapi/tests/test_udp_socket_private_shared.h | 42 | ||||
| -rw-r--r-- | ppapi/thunk/ppb_tcp_socket_private_api.h | 3 | ||||
| -rw-r--r-- | ppapi/thunk/ppb_udp_socket_private_api.h | 3 |
16 files changed, 558 insertions, 1320 deletions
diff --git a/ppapi/ppapi_shared.gypi b/ppapi/ppapi_shared.gypi index 5303b49..84673de 100644 --- a/ppapi/ppapi_shared.gypi +++ b/ppapi/ppapi_shared.gypi @@ -94,11 +94,6 @@ 'shared_impl/private/net_address_private_impl.cc', 'shared_impl/private/net_address_private_impl.h', - 'shared_impl/private/tcp_socket_private_impl.cc', - 'shared_impl/private/tcp_socket_private_impl.h', - 'shared_impl/private/udp_socket_private_impl.cc', - 'shared_impl/private/udp_socket_private_impl.h', - 'thunk/common.h', 'thunk/common.cc', 'thunk/enter.cc', diff --git a/ppapi/ppapi_sources.gypi b/ppapi/ppapi_sources.gypi index 2bd9583..f715443 100644 --- a/ppapi/ppapi_sources.gypi +++ b/ppapi/ppapi_sources.gypi @@ -253,14 +253,10 @@ 'tests/pp_thread.h', 'tests/test_case.cc', 'tests/test_case.h', - 'tests/test_tcp_socket_private_shared.cc', - 'tests/test_tcp_socket_private_shared.h', - 'tests/test_udp_socket_private_shared.cc', - 'tests/test_udp_socket_private_shared.h', 'tests/test_utils.cc', 'tests/testing_instance.cc', 'tests/testing_instance.h', - + # Compile-time tests 'tests/test_c_includes.c', 'tests/test_cpp_includes.cc', diff --git a/ppapi/proxy/ppb_tcp_socket_private_proxy.cc b/ppapi/proxy/ppb_tcp_socket_private_proxy.cc index b943889..4613784 100644 --- a/ppapi/proxy/ppb_tcp_socket_private_proxy.cc +++ b/ppapi/proxy/ppb_tcp_socket_private_proxy.cc @@ -4,46 +4,143 @@ #include "ppapi/proxy/ppb_tcp_socket_private_proxy.h" +#include <algorithm> +#include <cstring> #include <map> +#include "base/bind.h" #include "base/logging.h" +#include "base/memory/scoped_ptr.h" +#include "base/message_loop.h" +#include "base/task.h" +#include "ppapi/c/pp_errors.h" #include "ppapi/proxy/plugin_dispatcher.h" #include "ppapi/proxy/plugin_resource_tracker.h" #include "ppapi/proxy/ppapi_messages.h" -#include "ppapi/shared_impl/private/tcp_socket_private_impl.h" #include "ppapi/shared_impl/resource.h" +#include "ppapi/thunk/ppb_tcp_socket_private_api.h" #include "ppapi/thunk/thunk.h" +using ppapi::thunk::PPB_TCPSocket_Private_API; + namespace ppapi { namespace proxy { +const int32_t kTCPSocketMaxReadSize = 1024 * 1024; +const int32_t kTCPSocketMaxWriteSize = 1024 * 1024; + +class TCPSocket; + namespace { -typedef std::map<uint32, TCPSocketPrivateImpl*> IDToSocketMap; +typedef std::map<uint32, TCPSocket*> IDToSocketMap; IDToSocketMap* g_id_to_socket = NULL; -class TCPSocket : public TCPSocketPrivateImpl { +void AbortCallback(PP_CompletionCallback callback) { + if (callback.func) + PP_RunCompletionCallback(&callback, PP_ERROR_ABORTED); +} + +} // namespace + +class TCPSocket : public PPB_TCPSocket_Private_API, + public Resource { public: TCPSocket(const HostResource& resource, uint32 socket_id); virtual ~TCPSocket(); - virtual void SendConnect(const std::string& host, uint16_t port) OVERRIDE; - virtual void SendConnectWithNetAddress( - const PP_NetAddress_Private& addr) OVERRIDE; - virtual void SendSSLHandshake(const std::string& server_name, - uint16_t server_port) OVERRIDE; - virtual void SendRead(int32_t bytes_to_read) OVERRIDE; - virtual void SendWrite(const std::string& buffer) OVERRIDE; - virtual void SendDisconnect() OVERRIDE; + // Resource overrides. + virtual PPB_TCPSocket_Private_API* AsPPB_TCPSocket_Private_API() OVERRIDE; + + // PPB_TCPSocket_Private_API implementation. + virtual int32_t Connect(const char* host, + uint16_t port, + PP_CompletionCallback callback) OVERRIDE; + virtual int32_t ConnectWithNetAddress( + const PP_NetAddress_Private* addr, + PP_CompletionCallback callback) OVERRIDE; + virtual PP_Bool GetLocalAddress(PP_NetAddress_Private* local_addr) OVERRIDE; + virtual PP_Bool GetRemoteAddress(PP_NetAddress_Private* remote_addr) OVERRIDE; + virtual int32_t SSLHandshake(const char* server_name, + uint16_t server_port, + PP_CompletionCallback callback) OVERRIDE; + virtual int32_t Read(char* buffer, + int32_t bytes_to_read, + PP_CompletionCallback callback) OVERRIDE; + virtual int32_t Write(const char* buffer, + int32_t bytes_to_write, + PP_CompletionCallback callback) OVERRIDE; + virtual void Disconnect() OVERRIDE; + + // Notifications from the proxy. + void OnConnectCompleted(bool succeeded, + const PP_NetAddress_Private& local_addr, + const PP_NetAddress_Private& remote_addr); + void OnSSLHandshakeCompleted(bool succeeded); + void OnReadCompleted(bool succeeded, const std::string& data); + void OnWriteCompleted(bool succeeded, int32_t bytes_written); private: - void SendToBrowser(IPC::Message* msg); + enum ConnectionState { + // Before a connection is successfully established (including a connect + // request is pending or a previous connect request failed). + BEFORE_CONNECT, + // A connection has been successfully established (including a request of + // initiating SSL is pending). + CONNECTED, + // An SSL connection has been successfully established. + SSL_CONNECTED, + // The connection has been ended. + DISCONNECTED + }; + + bool IsConnected() const; + + PluginDispatcher* GetDispatcher() const { + return PluginDispatcher::GetForResource(this); + } + + // Backend for both Connect() and ConnectWithNetAddress(). To keep things + // generic, the message is passed in (on error, it's deleted). + int32_t ConnectWithMessage(IPC::Message* msg, + PP_CompletionCallback callback); + + void PostAbortAndClearIfNecessary(PP_CompletionCallback* callback); + + uint32 socket_id_; + ConnectionState connection_state_; + + PP_CompletionCallback connect_callback_; + PP_CompletionCallback ssl_handshake_callback_; + PP_CompletionCallback read_callback_; + PP_CompletionCallback write_callback_; + + char* read_buffer_; + int32_t bytes_to_read_; + + PP_NetAddress_Private local_addr_; + PP_NetAddress_Private remote_addr_; DISALLOW_COPY_AND_ASSIGN(TCPSocket); }; TCPSocket::TCPSocket(const HostResource& resource, uint32 socket_id) - : TCPSocketPrivateImpl(resource, socket_id) { + : Resource(resource), + socket_id_(socket_id), + connection_state_(BEFORE_CONNECT), + connect_callback_(PP_BlockUntilComplete()), + ssl_handshake_callback_(PP_BlockUntilComplete()), + read_callback_(PP_BlockUntilComplete()), + write_callback_(PP_BlockUntilComplete()), + read_buffer_(NULL), + bytes_to_read_(-1) { + DCHECK(socket_id != 0); + + local_addr_.size = 0; + memset(local_addr_.data, 0, sizeof(local_addr_.data)); + remote_addr_.size = 0; + memset(remote_addr_.data, 0, sizeof(remote_addr_.data)); + if (!g_id_to_socket) g_id_to_socket = new IDToSocketMap(); DCHECK(g_id_to_socket->find(socket_id) == g_id_to_socket->end()); @@ -54,44 +151,236 @@ TCPSocket::~TCPSocket() { Disconnect(); } -void TCPSocket::SendConnect(const std::string& host, uint16_t port) { - SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Connect(socket_id_, host, port)); +PPB_TCPSocket_Private_API* TCPSocket::AsPPB_TCPSocket_Private_API() { + return this; } -void TCPSocket::SendConnectWithNetAddress(const PP_NetAddress_Private& addr) { - SendToBrowser( - new PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress(socket_id_, addr)); +int32_t TCPSocket::Connect(const char* host, + uint16_t port, + PP_CompletionCallback callback) { + if (!host) + return PP_ERROR_BADARGUMENT; + + return ConnectWithMessage( + new PpapiHostMsg_PPBTCPSocket_Connect(socket_id_, host, port), + callback); } -void TCPSocket::SendSSLHandshake(const std::string& server_name, - uint16_t server_port) { - SendToBrowser(new PpapiHostMsg_PPBTCPSocket_SSLHandshake( - socket_id_, server_name, server_port)); +int32_t TCPSocket::ConnectWithNetAddress( + const PP_NetAddress_Private* addr, + PP_CompletionCallback callback) { + if (!addr) + return PP_ERROR_BADARGUMENT; + + return ConnectWithMessage( + new PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress( + socket_id_, *addr), + callback); +} + +PP_Bool TCPSocket::GetLocalAddress(PP_NetAddress_Private* local_addr) { + if (!IsConnected() || !local_addr) + return PP_FALSE; + + *local_addr = local_addr_; + return PP_TRUE; +} + +PP_Bool TCPSocket::GetRemoteAddress(PP_NetAddress_Private* remote_addr) { + if (!IsConnected() || !remote_addr) + return PP_FALSE; + + *remote_addr = remote_addr_; + return PP_TRUE; +} + +int32_t TCPSocket::SSLHandshake(const char* server_name, + uint16_t server_port, + PP_CompletionCallback callback) { + if (!server_name) + return PP_ERROR_BADARGUMENT; + if (!callback.func) + return PP_ERROR_BLOCKS_MAIN_THREAD; + + if (connection_state_ != CONNECTED) + return PP_ERROR_FAILED; + if (ssl_handshake_callback_.func || read_callback_.func || + write_callback_.func) + return PP_ERROR_INPROGRESS; + + ssl_handshake_callback_ = callback; + + // Send the request, the browser will call us back via SSLHandshakeACK. + GetDispatcher()->SendToBrowser( + new PpapiHostMsg_PPBTCPSocket_SSLHandshake( + socket_id_, std::string(server_name), server_port)); + return PP_OK_COMPLETIONPENDING; } -void TCPSocket::SendRead(int32_t bytes_to_read) { - SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Read(socket_id_, bytes_to_read)); +int32_t TCPSocket::Read(char* buffer, + int32_t bytes_to_read, + PP_CompletionCallback callback) { + if (!buffer || bytes_to_read <= 0) + return PP_ERROR_BADARGUMENT; + if (!callback.func) + return PP_ERROR_BLOCKS_MAIN_THREAD; + + if (!IsConnected()) + return PP_ERROR_FAILED; + if (read_callback_.func || ssl_handshake_callback_.func) + return PP_ERROR_INPROGRESS; + + read_buffer_ = buffer; + bytes_to_read_ = std::min(bytes_to_read, kTCPSocketMaxReadSize); + read_callback_ = callback; + + // Send the request, the browser will call us back via ReadACK. + GetDispatcher()->SendToBrowser( + new PpapiHostMsg_PPBTCPSocket_Read(socket_id_, bytes_to_read_)); + return PP_OK_COMPLETIONPENDING; } -void TCPSocket::SendWrite(const std::string& buffer) { - SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Write(socket_id_, buffer)); +int32_t TCPSocket::Write(const char* buffer, + int32_t bytes_to_write, + PP_CompletionCallback callback) { + if (!buffer || bytes_to_write <= 0) + return PP_ERROR_BADARGUMENT; + if (!callback.func) + return PP_ERROR_BLOCKS_MAIN_THREAD; + + if (!IsConnected()) + return PP_ERROR_FAILED; + if (write_callback_.func || ssl_handshake_callback_.func) + return PP_ERROR_INPROGRESS; + + if (bytes_to_write > kTCPSocketMaxWriteSize) + bytes_to_write = kTCPSocketMaxWriteSize; + + write_callback_ = callback; + + // Send the request, the browser will call us back via WriteACK. + GetDispatcher()->SendToBrowser( + new PpapiHostMsg_PPBTCPSocket_Write( + socket_id_, std::string(buffer, bytes_to_write))); + return PP_OK_COMPLETIONPENDING; } -void TCPSocket::SendDisconnect() { +void TCPSocket::Disconnect() { + if (connection_state_ == DISCONNECTED) + return; + + connection_state_ = DISCONNECTED; // After removed from the mapping, this object won't receive any notifications // from the proxy. DCHECK(g_id_to_socket->find(socket_id_) != g_id_to_socket->end()); g_id_to_socket->erase(socket_id_); - SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Disconnect(socket_id_)); + + GetDispatcher()->SendToBrowser( + new PpapiHostMsg_PPBTCPSocket_Disconnect(socket_id_)); + socket_id_ = 0; + + PostAbortAndClearIfNecessary(&connect_callback_); + PostAbortAndClearIfNecessary(&ssl_handshake_callback_); + PostAbortAndClearIfNecessary(&read_callback_); + PostAbortAndClearIfNecessary(&write_callback_); + read_buffer_ = NULL; + bytes_to_read_ = -1; +} + +void TCPSocket::OnConnectCompleted( + bool succeeded, + const PP_NetAddress_Private& local_addr, + const PP_NetAddress_Private& remote_addr) { + if (connection_state_ != BEFORE_CONNECT || !connect_callback_.func) { + NOTREACHED(); + return; + } + + if (succeeded) { + local_addr_ = local_addr; + remote_addr_ = remote_addr; + connection_state_ = CONNECTED; + } + PP_RunAndClearCompletionCallback(&connect_callback_, + succeeded ? PP_OK : PP_ERROR_FAILED); } -void TCPSocket::SendToBrowser(IPC::Message* msg) { - PluginDispatcher::GetForResource(this)->SendToBrowser(msg); +void TCPSocket::OnSSLHandshakeCompleted(bool succeeded) { + if (connection_state_ != CONNECTED || !ssl_handshake_callback_.func) { + NOTREACHED(); + return; + } + + if (succeeded) { + connection_state_ = SSL_CONNECTED; + PP_RunAndClearCompletionCallback(&ssl_handshake_callback_, PP_OK); + } else { + PP_RunAndClearCompletionCallback(&ssl_handshake_callback_, PP_ERROR_FAILED); + Disconnect(); + } } -} // namespace +void TCPSocket::OnReadCompleted(bool succeeded, const std::string& data) { + if (!read_callback_.func || !read_buffer_) { + NOTREACHED(); + return; + } + + if (succeeded) { + CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_); + if (!data.empty()) + memcpy(read_buffer_, data.c_str(), data.size()); + } + read_buffer_ = NULL; + bytes_to_read_ = -1; + + PP_RunAndClearCompletionCallback( + &read_callback_, + succeeded ? static_cast<int32_t>(data.size()) : + static_cast<int32_t>(PP_ERROR_FAILED)); +} + +void TCPSocket::OnWriteCompleted(bool succeeded, int32_t bytes_written) { + if (!write_callback_.func || (succeeded && bytes_written < 0)) { + NOTREACHED(); + return; + } -//------------------------------------------------------------------------------ + PP_RunAndClearCompletionCallback( + &write_callback_, + succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED)); +} + +bool TCPSocket::IsConnected() const { + return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED; +} + +int32_t TCPSocket::ConnectWithMessage(IPC::Message* msg, + PP_CompletionCallback callback) { + scoped_ptr<IPC::Message> msg_deletor(msg); + if (!callback.func) + return PP_ERROR_BLOCKS_MAIN_THREAD; + if (connection_state_ != BEFORE_CONNECT) + return PP_ERROR_FAILED; + if (connect_callback_.func) + return PP_ERROR_INPROGRESS; // Can only have one pending request. + + connect_callback_ = callback; + // Send the request, the browser will call us back via ConnectACK. + GetDispatcher()->SendToBrowser(msg_deletor.release()); + return PP_OK_COMPLETIONPENDING; +} + +void TCPSocket::PostAbortAndClearIfNecessary( + PP_CompletionCallback* callback) { + DCHECK(callback); + + if (callback->func) { + MessageLoop::current()->PostTask( + FROM_HERE, base::Bind(&AbortCallback, *callback)); + *callback = PP_BlockUntilComplete(); + } +} PPB_TCPSocket_Private_Proxy::PPB_TCPSocket_Private_Proxy(Dispatcher* dispatcher) : InterfaceProxy(dispatcher) { diff --git a/ppapi/proxy/ppb_tcp_socket_private_proxy.h b/ppapi/proxy/ppb_tcp_socket_private_proxy.h index 3e50b9f..ec89fe2 100644 --- a/ppapi/proxy/ppb_tcp_socket_private_proxy.h +++ b/ppapi/proxy/ppb_tcp_socket_private_proxy.h @@ -17,6 +17,13 @@ namespace ppapi { namespace proxy { +// The maximum number of bytes that each PpapiHostMsg_PPBTCPSocket_Read +// message is allowed to request. +PPAPI_PROXY_EXPORT extern const int32_t kTCPSocketMaxReadSize; +// The maximum number of bytes that each PpapiHostMsg_PPBTCPSocket_Write +// message is allowed to carry. +PPAPI_PROXY_EXPORT extern const int32_t kTCPSocketMaxWriteSize; + class PPB_TCPSocket_Private_Proxy : public InterfaceProxy { public: PPB_TCPSocket_Private_Proxy(Dispatcher* dispatcher); diff --git a/ppapi/proxy/ppb_udp_socket_private_proxy.cc b/ppapi/proxy/ppb_udp_socket_private_proxy.cc index 444a7da..1347049 100644 --- a/ppapi/proxy/ppb_udp_socket_private_proxy.cc +++ b/ppapi/proxy/ppb_udp_socket_private_proxy.cc @@ -4,43 +4,113 @@ #include "ppapi/proxy/ppb_udp_socket_private_proxy.h" +#include <algorithm> +#include <cstring> #include <map> +#include "base/bind.h" #include "base/logging.h" +#include "base/memory/scoped_ptr.h" +#include "base/message_loop.h" +#include "base/task.h" +#include "ppapi/c/pp_errors.h" #include "ppapi/proxy/plugin_dispatcher.h" #include "ppapi/proxy/plugin_resource_tracker.h" #include "ppapi/proxy/ppapi_messages.h" -#include "ppapi/shared_impl/private/udp_socket_private_impl.h" #include "ppapi/shared_impl/resource.h" +#include "ppapi/thunk/ppb_udp_socket_private_api.h" #include "ppapi/thunk/thunk.h" +using ppapi::thunk::PPB_UDPSocket_Private_API; + namespace ppapi { namespace proxy { +const int32_t kUDPSocketMaxReadSize = 1024 * 1024; +const int32_t kUDPSocketMaxWriteSize = 1024 * 1024; + namespace { -typedef std::map<uint32, UDPSocketPrivateImpl*> IDToSocketMap; +class UDPSocket; + +typedef std::map<uint32, UDPSocket*> IDToSocketMap; IDToSocketMap* g_id_to_socket = NULL; -class UDPSocket : public UDPSocketPrivateImpl { +void AbortCallback(PP_CompletionCallback callback) { + if (callback.func) + PP_RunCompletionCallback(&callback, PP_ERROR_ABORTED); +} + +class UDPSocket : public PPB_UDPSocket_Private_API, + public Resource { public: UDPSocket(const HostResource& resource, uint32 socket_id); virtual ~UDPSocket(); - virtual void SendBind(const PP_NetAddress_Private& addr) OVERRIDE; - virtual void SendRecvFrom(int32_t num_bytes) OVERRIDE; - virtual void SendSendTo(const std::string& data, - const PP_NetAddress_Private& addr) OVERRIDE; - virtual void SendClose() OVERRIDE; + // ResourceObjectBase overrides. + virtual PPB_UDPSocket_Private_API* AsPPB_UDPSocket_Private_API() OVERRIDE; + + // PPB_UDPSocket_Private_API implementation. + virtual int32_t Bind(const PP_NetAddress_Private* addr, + PP_CompletionCallback callback) OVERRIDE; + virtual int32_t RecvFrom(char* buffer, + int32_t num_bytes, + PP_CompletionCallback callback) OVERRIDE; + virtual PP_Bool GetRecvFromAddress(PP_NetAddress_Private* addr) OVERRIDE; + + virtual int32_t SendTo(const char* buffer, + int32_t num_bytes, + const PP_NetAddress_Private* addr, + PP_CompletionCallback callback) OVERRIDE; + virtual void Close() OVERRIDE; + + // Notifications from the proxy. + void OnBindCompleted(bool succeeded); + void OnRecvFromCompleted(bool succeeded, + const std::string& data, + const PP_NetAddress_Private& addr); + void OnSendToCompleted(bool succeeded, + int32_t bytes_written); private: - void SendToBrowser(IPC::Message* msg); + void PostAbortAndClearIfNecessary(PP_CompletionCallback* callback); + + PluginDispatcher* GetDispatcher() const { + return PluginDispatcher::GetForResource(this); + } + + uint32 socket_id_; + + bool binded_; + bool closed_; + + PP_CompletionCallback bind_callback_; + PP_CompletionCallback recvfrom_callback_; + PP_CompletionCallback sendto_callback_; + + char* read_buffer_; + int32_t bytes_to_read_; + + PP_NetAddress_Private recvfrom_addr_; DISALLOW_COPY_AND_ASSIGN(UDPSocket); }; UDPSocket::UDPSocket(const HostResource& resource, uint32 socket_id) - : UDPSocketPrivateImpl(resource, socket_id) { + : Resource(resource), + socket_id_(socket_id), + binded_(false), + closed_(false), + bind_callback_(PP_BlockUntilComplete()), + recvfrom_callback_(PP_BlockUntilComplete()), + sendto_callback_(PP_BlockUntilComplete()), + read_buffer_(NULL), + bytes_to_read_(-1) { + DCHECK(socket_id != 0); + + recvfrom_addr_.size = 0; + memset(recvfrom_addr_.data, 0, sizeof(recvfrom_addr_.data)); + if (!g_id_to_socket) g_id_to_socket = new IDToSocketMap(); DCHECK(g_id_to_socket->find(socket_id) == g_id_to_socket->end()); @@ -51,34 +121,159 @@ UDPSocket::~UDPSocket() { Close(); } -void UDPSocket::SendBind(const PP_NetAddress_Private& addr) { - SendToBrowser(new PpapiHostMsg_PPBUDPSocket_Bind(socket_id_, addr)); +PPB_UDPSocket_Private_API* UDPSocket::AsPPB_UDPSocket_Private_API() { + return this; } -void UDPSocket::SendRecvFrom(int32_t num_bytes) { - SendToBrowser(new PpapiHostMsg_PPBUDPSocket_RecvFrom(socket_id_, num_bytes)); +int32_t UDPSocket::Bind(const PP_NetAddress_Private* addr, + PP_CompletionCallback callback) { + if (!addr || !callback.func) + return PP_ERROR_BADARGUMENT; + if (binded_ || closed_) + return PP_ERROR_FAILED; + if (bind_callback_.func) + return PP_ERROR_INPROGRESS; + + bind_callback_ = callback; + + GetDispatcher()->SendToBrowser( + new PpapiHostMsg_PPBUDPSocket_Bind(socket_id_, *addr)); + + return PP_OK_COMPLETIONPENDING; } -void UDPSocket::SendSendTo(const std::string& data, - const PP_NetAddress_Private& addr) { - SendToBrowser(new PpapiHostMsg_PPBUDPSocket_SendTo(socket_id_, data, addr)); +int32_t UDPSocket::RecvFrom(char* buffer, + int32_t num_bytes, + PP_CompletionCallback callback) { + if (!buffer || num_bytes <= 0 || !callback.func) + return PP_ERROR_BADARGUMENT; + if (!binded_) + return PP_ERROR_FAILED; + if (recvfrom_callback_.func) + return PP_ERROR_INPROGRESS; + + read_buffer_ = buffer; + bytes_to_read_ = std::min(num_bytes, kUDPSocketMaxReadSize); + recvfrom_callback_ = callback; + + // Send the request, the browser will call us back via RecvFromACK. + GetDispatcher()->SendToBrowser( + new PpapiHostMsg_PPBUDPSocket_RecvFrom( + socket_id_, num_bytes)); + return PP_OK_COMPLETIONPENDING; } -void UDPSocket::SendClose() { - // After removed from the mapping, this object won't receive any notifications +PP_Bool UDPSocket::GetRecvFromAddress(PP_NetAddress_Private* addr) { + if (!addr) + return PP_FALSE; + + *addr = recvfrom_addr_; + return PP_TRUE; +} + +int32_t UDPSocket::SendTo(const char* buffer, + int32_t num_bytes, + const PP_NetAddress_Private* addr, + PP_CompletionCallback callback) { + if (!buffer || num_bytes <= 0 || !addr || !callback.func) + return PP_ERROR_BADARGUMENT; + if (!binded_) + return PP_ERROR_FAILED; + if (sendto_callback_.func) + return PP_ERROR_INPROGRESS; + + if (num_bytes > kUDPSocketMaxWriteSize) + num_bytes = kUDPSocketMaxWriteSize; + + sendto_callback_ = callback; + + // Send the request, the browser will call us back via SendToACK. + GetDispatcher()->SendToBrowser( + new PpapiHostMsg_PPBUDPSocket_SendTo( + socket_id_, std::string(buffer, num_bytes), *addr)); + + return PP_OK_COMPLETIONPENDING; +} + +void UDPSocket::Close() { + if(closed_) + return; + + binded_ = false; + closed_ = true; + + // After removed from the mapping, this object won't receive any notfications // from the proxy. DCHECK(g_id_to_socket->find(socket_id_) != g_id_to_socket->end()); g_id_to_socket->erase(socket_id_); - SendToBrowser(new PpapiHostMsg_PPBUDPSocket_Close(socket_id_)); + + GetDispatcher()->SendToBrowser( + new PpapiHostMsg_PPBUDPSocket_Close(socket_id_)); + socket_id_ = 0; + + PostAbortAndClearIfNecessary(&bind_callback_); + PostAbortAndClearIfNecessary(&recvfrom_callback_); + PostAbortAndClearIfNecessary(&sendto_callback_); } -void UDPSocket::SendToBrowser(IPC::Message* msg) { - PluginDispatcher::GetForResource(this)->SendToBrowser(msg); +void UDPSocket::OnBindCompleted(bool succeeded) { + if (!bind_callback_.func) { + NOTREACHED(); + return; + } + + if (succeeded) + binded_ = true; + + PP_RunAndClearCompletionCallback(&bind_callback_, + succeeded ? PP_OK : PP_ERROR_FAILED); } -} // namespace +void UDPSocket::OnRecvFromCompleted(bool succeeded, + const std::string& data, + const PP_NetAddress_Private& addr) { + if (!recvfrom_callback_.func || !read_buffer_) { + NOTREACHED(); + return; + } -//------------------------------------------------------------------------------ + if (succeeded) { + CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_); + if (!data.empty()) + memcpy(read_buffer_, data.c_str(), data.size()); + } + read_buffer_ = NULL; + bytes_to_read_ = -1; + recvfrom_addr_ = addr; + + PP_RunAndClearCompletionCallback( + &recvfrom_callback_, + succeeded ? static_cast<int32_t>(data.size()) : + static_cast<int32_t>(PP_ERROR_FAILED)); +} + +void UDPSocket::OnSendToCompleted(bool succeeded, int32_t bytes_written) { + if (!sendto_callback_.func) { + NOTREACHED(); + return; + } + + PP_RunAndClearCompletionCallback( + &sendto_callback_, + succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED)); +} + +void UDPSocket::PostAbortAndClearIfNecessary( + PP_CompletionCallback* callback) { + DCHECK(callback); + + if (callback->func) { + MessageLoop::current()->PostTask( + FROM_HERE, base::Bind(&AbortCallback, *callback)); + *callback = PP_BlockUntilComplete(); + } +} +} // namespace PPB_UDPSocket_Private_Proxy::PPB_UDPSocket_Private_Proxy(Dispatcher* dispatcher) : InterfaceProxy(dispatcher) { diff --git a/ppapi/proxy/ppb_udp_socket_private_proxy.h b/ppapi/proxy/ppb_udp_socket_private_proxy.h index c6c9e68..337cf6b 100644 --- a/ppapi/proxy/ppb_udp_socket_private_proxy.h +++ b/ppapi/proxy/ppb_udp_socket_private_proxy.h @@ -16,6 +16,13 @@ namespace ppapi { namespace proxy { +// The maximum number of bytes that each PpapiHostMsg_PPBUDPSocket_RecvFrom +// message is allowed to request. +extern const int32_t kUDPSocketMaxReadSize; +// The maximum number of bytes that each PpapiHostMsg_PPBUDPSocket_SendTo +// message is allowed to carry. +extern const int32_t kUDPSocketMaxWriteSize; + class PPB_UDPSocket_Private_Proxy : public InterfaceProxy { public: PPB_UDPSocket_Private_Proxy(Dispatcher* dispatcher); @@ -50,3 +57,4 @@ class PPB_UDPSocket_Private_Proxy : public InterfaceProxy { } // namespace ppapi #endif // PPAPI_PROXY_PPB_UDP_SOCKET_PRIVATE_PROXY_H_ + diff --git a/ppapi/shared_impl/private/tcp_socket_private_impl.cc b/ppapi/shared_impl/private/tcp_socket_private_impl.cc deleted file mode 100644 index 7ec1535..0000000 --- a/ppapi/shared_impl/private/tcp_socket_private_impl.cc +++ /dev/null @@ -1,289 +0,0 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "ppapi/shared_impl/private/tcp_socket_private_impl.h" - -#include <string.h> - -#include <algorithm> - -#include "base/basictypes.h" -#include "base/bind.h" -#include "base/logging.h" -#include "base/message_loop.h" -#include "ppapi/c/pp_completion_callback.h" -#include "ppapi/c/pp_errors.h" - -namespace ppapi { - -namespace { - -void AbortCallback(PP_CompletionCallback callback) { - PP_RunCompletionCallback(&callback, PP_ERROR_ABORTED); -} - -} // namespace - -const int32_t TCPSocketPrivateImpl::kMaxReadSize = 1024 * 1024; -const int32_t TCPSocketPrivateImpl::kMaxWriteSize = 1024 * 1024; - -TCPSocketPrivateImpl::TCPSocketPrivateImpl(PP_Instance instance, - uint32 socket_id) - : Resource(instance) { - Init(socket_id); -} - -TCPSocketPrivateImpl::TCPSocketPrivateImpl(const HostResource& resource, - uint32 socket_id) - : Resource(resource) { - Init(socket_id); -} - -TCPSocketPrivateImpl::~TCPSocketPrivateImpl() { -} - -thunk::PPB_TCPSocket_Private_API* -TCPSocketPrivateImpl::AsPPB_TCPSocket_Private_API() { - return this; -} - -int32_t TCPSocketPrivateImpl::Connect(const char* host, - uint16_t port, - PP_CompletionCallback callback) { - if (!host) - return PP_ERROR_BADARGUMENT; - if (!callback.func) - return PP_ERROR_BLOCKS_MAIN_THREAD; - if (connection_state_ != BEFORE_CONNECT) - return PP_ERROR_FAILED; - if (connect_callback_.func) - return PP_ERROR_INPROGRESS; // Can only have one pending request. - - connect_callback_ = callback; - // Send the request, the browser will call us back via ConnectACK. - SendConnect(host, port); - return PP_OK_COMPLETIONPENDING; -} - -int32_t TCPSocketPrivateImpl::ConnectWithNetAddress( - const PP_NetAddress_Private* addr, - PP_CompletionCallback callback) { - if (!addr) - return PP_ERROR_BADARGUMENT; - if (!callback.func) - return PP_ERROR_BLOCKS_MAIN_THREAD; - if (connection_state_ != BEFORE_CONNECT) - return PP_ERROR_FAILED; - if (connect_callback_.func) - return PP_ERROR_INPROGRESS; // Can only have one pending request. - - connect_callback_ = callback; - // Send the request, the browser will call us back via ConnectACK. - SendConnectWithNetAddress(*addr); - return PP_OK_COMPLETIONPENDING; -} - -PP_Bool TCPSocketPrivateImpl::GetLocalAddress( - PP_NetAddress_Private* local_addr) { - if (!IsConnected() || !local_addr) - return PP_FALSE; - - *local_addr = local_addr_; - return PP_TRUE; -} - -PP_Bool TCPSocketPrivateImpl::GetRemoteAddress( - PP_NetAddress_Private* remote_addr) { - if (!IsConnected() || !remote_addr) - return PP_FALSE; - - *remote_addr = remote_addr_; - return PP_TRUE; -} - -int32_t TCPSocketPrivateImpl::SSLHandshake(const char* server_name, - uint16_t server_port, - PP_CompletionCallback callback) { - if (!server_name) - return PP_ERROR_BADARGUMENT; - if (!callback.func) - return PP_ERROR_BLOCKS_MAIN_THREAD; - - if (connection_state_ != CONNECTED) - return PP_ERROR_FAILED; - if (ssl_handshake_callback_.func || read_callback_.func || - write_callback_.func) - return PP_ERROR_INPROGRESS; - - ssl_handshake_callback_ = callback; - - // Send the request, the browser will call us back via SSLHandshakeACK. - SendSSLHandshake(server_name, server_port); - return PP_OK_COMPLETIONPENDING; -} - -int32_t TCPSocketPrivateImpl::Read(char* buffer, - int32_t bytes_to_read, - PP_CompletionCallback callback) { - if (!buffer || bytes_to_read <= 0) - return PP_ERROR_BADARGUMENT; - if (!callback.func) - return PP_ERROR_BLOCKS_MAIN_THREAD; - - if (!IsConnected()) - return PP_ERROR_FAILED; - if (read_callback_.func || ssl_handshake_callback_.func) - return PP_ERROR_INPROGRESS; - // TODO(dmichael): use some other strategy for determining if an - // operation is in progress - read_buffer_ = buffer; - bytes_to_read_ = std::min(bytes_to_read, kMaxReadSize); - read_callback_ = callback; - - // Send the request, the browser will call us back via ReadACK. - SendRead(bytes_to_read_); - return PP_OK_COMPLETIONPENDING; -} - -int32_t TCPSocketPrivateImpl::Write(const char* buffer, - int32_t bytes_to_write, - PP_CompletionCallback callback) { - if (!buffer || bytes_to_write <= 0) - return PP_ERROR_BADARGUMENT; - if (!callback.func) - return PP_ERROR_BLOCKS_MAIN_THREAD; - - if (!IsConnected()) - return PP_ERROR_FAILED; - if (write_callback_.func || ssl_handshake_callback_.func) - return PP_ERROR_INPROGRESS; - - if (bytes_to_write > kMaxWriteSize) - bytes_to_write = kMaxWriteSize; - - write_callback_ = callback; - - // Send the request, the browser will call us back via WriteACK. - SendWrite(std::string(buffer, bytes_to_write)); - return PP_OK_COMPLETIONPENDING; -} - -void TCPSocketPrivateImpl::Disconnect() { - if (connection_state_ == DISCONNECTED) - return; - - connection_state_ = DISCONNECTED; - - SendDisconnect(); - socket_id_ = 0; - - PostAbortAndClearIfNecessary(&connect_callback_); - PostAbortAndClearIfNecessary(&ssl_handshake_callback_); - PostAbortAndClearIfNecessary(&read_callback_); - PostAbortAndClearIfNecessary(&write_callback_); - read_buffer_ = NULL; - bytes_to_read_ = -1; -} - -void TCPSocketPrivateImpl::OnConnectCompleted( - bool succeeded, - const PP_NetAddress_Private& local_addr, - const PP_NetAddress_Private& remote_addr) { - if (connection_state_ != BEFORE_CONNECT || !connect_callback_.func) { - NOTREACHED(); - return; - } - - if (succeeded) { - local_addr_ = local_addr; - remote_addr_ = remote_addr; - connection_state_ = CONNECTED; - } - PP_RunAndClearCompletionCallback(&connect_callback_, - succeeded ? PP_OK : PP_ERROR_FAILED); -} - -void TCPSocketPrivateImpl::OnSSLHandshakeCompleted(bool succeeded) { - if (connection_state_ != CONNECTED || !ssl_handshake_callback_.func) { - NOTREACHED(); - return; - } - - if (succeeded) { - connection_state_ = SSL_CONNECTED; - PP_RunAndClearCompletionCallback(&ssl_handshake_callback_, PP_OK); - } else { - PP_RunAndClearCompletionCallback(&ssl_handshake_callback_, PP_ERROR_FAILED); - Disconnect(); - } -} - -void TCPSocketPrivateImpl::OnReadCompleted(bool succeeded, - const std::string& data) { - if (!read_callback_.func || !read_buffer_) { - NOTREACHED(); - return; - } - - if (succeeded) { - CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_); - if (!data.empty()) - memcpy(read_buffer_, data.c_str(), data.size()); - } - read_buffer_ = NULL; - bytes_to_read_ = -1; - - PP_RunAndClearCompletionCallback( - &read_callback_, - succeeded ? static_cast<int32_t>(data.size()) : - static_cast<int32_t>(PP_ERROR_FAILED)); -} - -void TCPSocketPrivateImpl::OnWriteCompleted(bool succeeded, - int32_t bytes_written) { - if (!write_callback_.func || (succeeded && bytes_written < 0)) { - NOTREACHED(); - return; - } - - PP_RunAndClearCompletionCallback( - &write_callback_, - succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED)); -} - -void TCPSocketPrivateImpl::Init(uint32 socket_id) { - DCHECK(socket_id != 0); - socket_id_ = socket_id; - connection_state_ = BEFORE_CONNECT; - connect_callback_ = PP_BlockUntilComplete(); - ssl_handshake_callback_ = PP_BlockUntilComplete(); - read_callback_ = PP_BlockUntilComplete(); - write_callback_ = PP_BlockUntilComplete(); - read_buffer_ = NULL; - bytes_to_read_ = -1; - - local_addr_.size = 0; - memset(local_addr_.data, 0, - arraysize(local_addr_.data) * sizeof(*local_addr_.data)); - remote_addr_.size = 0; - memset(remote_addr_.data, 0, - arraysize(remote_addr_.data) * sizeof(*remote_addr_.data)); -} - -bool TCPSocketPrivateImpl::IsConnected() const { - return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED; -} - -void TCPSocketPrivateImpl::PostAbortAndClearIfNecessary( - PP_CompletionCallback* callback) { - DCHECK(callback); - - if (callback->func) { - MessageLoop::current()->PostTask(FROM_HERE, - base::Bind(&AbortCallback, *callback)); - *callback = PP_BlockUntilComplete(); - } -} - -} // namespace ppapi diff --git a/ppapi/shared_impl/private/tcp_socket_private_impl.h b/ppapi/shared_impl/private/tcp_socket_private_impl.h deleted file mode 100644 index 095f155..0000000 --- a/ppapi/shared_impl/private/tcp_socket_private_impl.h +++ /dev/null @@ -1,116 +0,0 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef PPAPI_SHARED_IMPL_PRIVATE_TCP_SOCKET_PRIVATE_IMPL_H_ -#define PPAPI_SHARED_IMPL_PRIVATE_TCP_SOCKET_PRIVATE_IMPL_H_ - -#include <string> - -#include "base/compiler_specific.h" -#include "ppapi/shared_impl/resource.h" -#include "ppapi/thunk/ppb_tcp_socket_private_api.h" - -namespace ppapi { - -// This class provides the shared implementation of a -// PPB_TCPSocket_Private. The functions that actually send messages -// to browser are implemented differently for the proxied and -// non-proxied derived classes. -class PPAPI_SHARED_EXPORT TCPSocketPrivateImpl - : public thunk::PPB_TCPSocket_Private_API, - public Resource { - public: - // C-tor used in Impl case. - TCPSocketPrivateImpl(PP_Instance instance, uint32 socket_id); - // C-tor used in Proxy case. - TCPSocketPrivateImpl(const HostResource& resource, uint32 socket_id); - - virtual ~TCPSocketPrivateImpl(); - - // The maximum number of bytes that each PpapiHostMsg_PPBTCPSocket_Read - // message is allowed to request. - static const int32_t kMaxReadSize; - // The maximum number of bytes that each PpapiHostMsg_PPBTCPSocket_Write - // message is allowed to carry. - static const int32_t kMaxWriteSize; - - // Resource overrides. - virtual PPB_TCPSocket_Private_API* AsPPB_TCPSocket_Private_API() OVERRIDE; - - // PPB_TCPSocket_Private_API implementation. - virtual int32_t Connect(const char* host, - uint16_t port, - PP_CompletionCallback callback) OVERRIDE; - virtual int32_t ConnectWithNetAddress( - const PP_NetAddress_Private* addr, - PP_CompletionCallback callback) OVERRIDE; - virtual PP_Bool GetLocalAddress(PP_NetAddress_Private* local_addr) OVERRIDE; - virtual PP_Bool GetRemoteAddress(PP_NetAddress_Private* remote_addr) OVERRIDE; - virtual int32_t SSLHandshake(const char* server_name, - uint16_t server_port, - PP_CompletionCallback callback) OVERRIDE; - virtual int32_t Read(char* buffer, - int32_t bytes_to_read, - PP_CompletionCallback callback) OVERRIDE; - virtual int32_t Write(const char* buffer, - int32_t bytes_to_write, - PP_CompletionCallback callback) OVERRIDE; - virtual void Disconnect() OVERRIDE; - - // Notifications on operations completion. - void OnConnectCompleted(bool succeeded, - const PP_NetAddress_Private& local_addr, - const PP_NetAddress_Private& remote_addr); - void OnSSLHandshakeCompleted(bool succeeded); - void OnReadCompleted(bool succeeded, const std::string& data); - void OnWriteCompleted(bool succeeded, int32_t bytes_written); - - // Send functions that need to be implemented differently for the - // proxied and non-proxied derived classes. - virtual void SendConnect(const std::string& host, uint16_t port) = 0; - virtual void SendConnectWithNetAddress(const PP_NetAddress_Private& addr) = 0; - virtual void SendSSLHandshake(const std::string& server_name, - uint16_t server_port) = 0; - virtual void SendRead(int32_t bytes_to_read) = 0; - virtual void SendWrite(const std::string& buffer) = 0; - virtual void SendDisconnect() = 0; - - protected: - enum ConnectionState { - // Before a connection is successfully established (including a connect - // request is pending or a previous connect request failed). - BEFORE_CONNECT, - // A connection has been successfully established (including a request of - // initiating SSL is pending). - CONNECTED, - // An SSL connection has been successfully established. - SSL_CONNECTED, - // The connection has been ended. - DISCONNECTED - }; - - void Init(uint32 socket_id); - bool IsConnected() const; - void PostAbortAndClearIfNecessary(PP_CompletionCallback* callback); - - uint32 socket_id_; - ConnectionState connection_state_; - - PP_CompletionCallback connect_callback_; - PP_CompletionCallback ssl_handshake_callback_; - PP_CompletionCallback read_callback_; - PP_CompletionCallback write_callback_; - - char* read_buffer_; - int32_t bytes_to_read_; - - PP_NetAddress_Private local_addr_; - PP_NetAddress_Private remote_addr_; - - DISALLOW_COPY_AND_ASSIGN(TCPSocketPrivateImpl); -}; - -} // namespace ppapi - -#endif // PPAPI_SHARED_IMPL_PRIVATE_TCP_SOCKET_PRIVATE_IMPL_H_ diff --git a/ppapi/shared_impl/private/udp_socket_private_impl.cc b/ppapi/shared_impl/private/udp_socket_private_impl.cc deleted file mode 100644 index 388d159..0000000 --- a/ppapi/shared_impl/private/udp_socket_private_impl.cc +++ /dev/null @@ -1,209 +0,0 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "ppapi/shared_impl/private/udp_socket_private_impl.h" - -#include <string.h> - -#include <algorithm> - -#include "base/basictypes.h" -#include "base/bind.h" -#include "base/logging.h" -#include "base/message_loop.h" -#include "ppapi/c/pp_completion_callback.h" -#include "ppapi/c/pp_errors.h" - -namespace ppapi { - -namespace { - -void AbortCallback(PP_CompletionCallback callback) { - PP_RunCompletionCallback(&callback, PP_ERROR_ABORTED); -} - -} // namespace - -const int32_t UDPSocketPrivateImpl::kMaxReadSize = 1024 * 1024; -const int32_t UDPSocketPrivateImpl::kMaxWriteSize = 1024 * 1024; - -UDPSocketPrivateImpl::UDPSocketPrivateImpl(const HostResource& resource, - uint32 socket_id) - : Resource(resource) { - Init(socket_id); -} - -UDPSocketPrivateImpl::UDPSocketPrivateImpl(PP_Instance instance, - uint32 socket_id) - : Resource(instance) { - Init(socket_id); -} - -UDPSocketPrivateImpl::~UDPSocketPrivateImpl() { -} - -thunk::PPB_UDPSocket_Private_API* -UDPSocketPrivateImpl::AsPPB_UDPSocket_Private_API() { - return this; -} - -int32_t UDPSocketPrivateImpl::Bind(const PP_NetAddress_Private* addr, - PP_CompletionCallback callback) { - if (!addr || !callback.func) - return PP_ERROR_BADARGUMENT; - if (bound_ || closed_) - return PP_ERROR_FAILED; - if (bind_callback_.func) - return PP_ERROR_INPROGRESS; - // TODO(dmichael): use some other strategy for determining if an - // operation is in progress - - bind_callback_ = callback; - - // Send the request, the browser will call us back via BindACK. - SendBind(*addr); - return PP_OK_COMPLETIONPENDING; -} - -int32_t UDPSocketPrivateImpl::RecvFrom(char* buffer, - int32_t num_bytes, - PP_CompletionCallback callback) { - if (!buffer || num_bytes <= 0 || !callback.func) - return PP_ERROR_BADARGUMENT; - if (!bound_) - return PP_ERROR_FAILED; - if (recvfrom_callback_.func) - return PP_ERROR_INPROGRESS; - - read_buffer_ = buffer; - bytes_to_read_ = std::min(num_bytes, kMaxReadSize); - recvfrom_callback_ = callback; - - // Send the request, the browser will call us back via RecvFromACK. - SendRecvFrom(bytes_to_read_); - return PP_OK_COMPLETIONPENDING; -} - -PP_Bool UDPSocketPrivateImpl::GetRecvFromAddress(PP_NetAddress_Private* addr) { - if (!addr) - return PP_FALSE; - - *addr = recvfrom_addr_; - return PP_TRUE; -} - -int32_t UDPSocketPrivateImpl::SendTo(const char* buffer, - int32_t num_bytes, - const PP_NetAddress_Private* addr, - PP_CompletionCallback callback) { - if (!buffer || num_bytes <= 0 || !addr || !callback.func) - return PP_ERROR_BADARGUMENT; - if (!bound_) - return PP_ERROR_FAILED; - if (sendto_callback_.func) - return PP_ERROR_INPROGRESS; - - if (num_bytes > kMaxWriteSize) - num_bytes = kMaxWriteSize; - - sendto_callback_ = callback; - - // Send the request, the browser will call us back via SendToACK. - SendSendTo(std::string(buffer, num_bytes), *addr); - return PP_OK_COMPLETIONPENDING; -} - -void UDPSocketPrivateImpl::Close() { - if(closed_) - return; - - bound_ = false; - closed_ = true; - - SendClose(); - - socket_id_ = 0; - - PostAbortAndClearIfNecessary(&bind_callback_); - PostAbortAndClearIfNecessary(&recvfrom_callback_); - PostAbortAndClearIfNecessary(&sendto_callback_); -} - -void UDPSocketPrivateImpl::OnBindCompleted(bool succeeded) { - if (!bind_callback_.func) { - NOTREACHED(); - return; - } - - if (succeeded) - bound_ = true; - - PP_RunAndClearCompletionCallback(&bind_callback_, - succeeded ? PP_OK : PP_ERROR_FAILED); -} - -void UDPSocketPrivateImpl::OnRecvFromCompleted( - bool succeeded, - const std::string& data, - const PP_NetAddress_Private& addr) { - if (!recvfrom_callback_.func || !read_buffer_) { - NOTREACHED(); - return; - } - - if (succeeded) { - CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_); - if (!data.empty()) - memcpy(read_buffer_, data.c_str(), data.size()); - } - read_buffer_ = NULL; - bytes_to_read_ = -1; - recvfrom_addr_ = addr; - - PP_RunAndClearCompletionCallback( - &recvfrom_callback_, - succeeded ? static_cast<int32_t>(data.size()) : - static_cast<int32_t>(PP_ERROR_FAILED)); -} - -void UDPSocketPrivateImpl::OnSendToCompleted(bool succeeded, - int32_t bytes_written) { - if (!sendto_callback_.func) { - NOTREACHED(); - return; - } - - PP_RunAndClearCompletionCallback( - &sendto_callback_, - succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED)); -} - -void UDPSocketPrivateImpl::Init(uint32 socket_id) { - DCHECK(socket_id != 0); - socket_id_ = socket_id; - bound_ = false; - closed_ = false; - bind_callback_ = PP_BlockUntilComplete(); - recvfrom_callback_ = PP_BlockUntilComplete(); - sendto_callback_ = PP_BlockUntilComplete(); - read_buffer_ = NULL; - bytes_to_read_ = -1; - - recvfrom_addr_.size = 0; - memset(recvfrom_addr_.data, 0, - arraysize(recvfrom_addr_.data) * sizeof(*recvfrom_addr_.data)); -} - -void UDPSocketPrivateImpl::PostAbortAndClearIfNecessary( - PP_CompletionCallback* callback) { - DCHECK(callback); - - if (callback->func) { - MessageLoop::current()->PostTask(FROM_HERE, - base::Bind(&AbortCallback, *callback)); - *callback = PP_BlockUntilComplete(); - } -} - -} // namespace ppapi diff --git a/ppapi/shared_impl/private/udp_socket_private_impl.h b/ppapi/shared_impl/private/udp_socket_private_impl.h deleted file mode 100644 index 0f06e06..0000000 --- a/ppapi/shared_impl/private/udp_socket_private_impl.h +++ /dev/null @@ -1,92 +0,0 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef PPAPI_SHARED_IMPL_PRIVATE_UDP_SOCKET_PRIVATE_IMPL_H_ -#define PPAPI_SHARED_IMPL_PRIVATE_UDP_SOCKET_PRIVATE_IMPL_H_ - -#include <string> - -#include "base/compiler_specific.h" -#include "ppapi/shared_impl/resource.h" -#include "ppapi/thunk/ppb_udp_socket_private_api.h" - -namespace ppapi { - -// This class provides the shared implementation of a -// PPB_UDPSocket_Private. The functions that actually send messages -// to browser are implemented differently for the proxied and -// non-proxied derived classes. -class PPAPI_SHARED_EXPORT UDPSocketPrivateImpl - : public thunk::PPB_UDPSocket_Private_API, - public Resource { - public: - // C-tor used in Impl case. - UDPSocketPrivateImpl(PP_Instance instance, uint32 socket_id); - // C-tor used in Proxy case. - UDPSocketPrivateImpl(const HostResource& resource, uint32 socket_id); - - virtual ~UDPSocketPrivateImpl(); - - // The maximum number of bytes that each PpapiHostMsg_PPBUDPSocket_RecvFrom - // message is allowed to request. - static const int32_t kMaxReadSize; - // The maximum number of bytes that each PpapiHostMsg_PPBUDPSocket_SendTo - // message is allowed to carry. - static const int32_t kMaxWriteSize; - - // Resource overrides. - virtual PPB_UDPSocket_Private_API* AsPPB_UDPSocket_Private_API() OVERRIDE; - - // PPB_UDPSocket_Private_API implementation. - virtual int32_t Bind(const PP_NetAddress_Private* addr, - PP_CompletionCallback callback) OVERRIDE; - virtual int32_t RecvFrom(char* buffer, - int32_t num_bytes, - PP_CompletionCallback callback) OVERRIDE; - virtual PP_Bool GetRecvFromAddress(PP_NetAddress_Private* addr) OVERRIDE; - virtual int32_t SendTo(const char* buffer, - int32_t num_bytes, - const PP_NetAddress_Private* addr, - PP_CompletionCallback callback) OVERRIDE; - virtual void Close() OVERRIDE; - - // Notifications from the proxy. - void OnBindCompleted(bool succeeded); - void OnRecvFromCompleted(bool succeeded, - const std::string& data, - const PP_NetAddress_Private& addr); - void OnSendToCompleted(bool succeeded, int32_t bytes_written); - - // Send functions that need to be implemented differently for - // the proxied and non-proxied derived classes. - virtual void SendBind(const PP_NetAddress_Private& addr) = 0; - virtual void SendRecvFrom(int32_t num_bytes) = 0; - virtual void SendSendTo(const std::string& buffer, - const PP_NetAddress_Private& addr) = 0; - virtual void SendClose() = 0; - - protected: - void Init(uint32 socket_id); - void PostAbortAndClearIfNecessary(PP_CompletionCallback* callback); - - uint32 socket_id_; - - bool bound_; - bool closed_; - - PP_CompletionCallback bind_callback_; - PP_CompletionCallback recvfrom_callback_; - PP_CompletionCallback sendto_callback_; - - char* read_buffer_; - int32_t bytes_to_read_; - - PP_NetAddress_Private recvfrom_addr_; - - DISALLOW_COPY_AND_ASSIGN(UDPSocketPrivateImpl); -}; - -} // namespace ppapi - -#endif // PPAPI_SHARED_IMPL_PRIVATE_UDP_SOCKET_PRIVATE_IMPL_H_ diff --git a/ppapi/tests/test_tcp_socket_private_shared.cc b/ppapi/tests/test_tcp_socket_private_shared.cc deleted file mode 100644 index 7ca3666..0000000 --- a/ppapi/tests/test_tcp_socket_private_shared.cc +++ /dev/null @@ -1,271 +0,0 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "ppapi/tests/test_tcp_socket_private_shared.h" - -#include <string.h> -#include <new> -#include <string> -#include <vector> - -#include "ppapi/cpp/module.h" -#include "ppapi/tests/test_utils.h" -#include "ppapi/tests/testing_instance.h" - -REGISTER_TEST_CASE(TCPSocketPrivateShared); - -// TODO(ygorshenin): get rid of using external server in tests, -// http://crbug.com/105863 -const char* const TestTCPSocketPrivateShared::kHost = "www.google.com"; - -TestTCPSocketPrivateShared::TestTCPSocketPrivateShared( - TestingInstance* instance) - : TestCase(instance), tcp_socket_private_interface_(NULL) { -} - -bool TestTCPSocketPrivateShared::Init() { - tcp_socket_private_interface_ = - reinterpret_cast<PPB_TCPSocket_Private const*>( - pp::Module::Get()->GetBrowserInterface( - PPB_TCPSOCKET_PRIVATE_INTERFACE)); - if (!tcp_socket_private_interface_) - instance_->AppendError("TCPSocketPrivate interface not available"); - return tcp_socket_private_interface_ && InitTestingInterface(); -} - -void TestTCPSocketPrivateShared::RunTests(const std::string& filter) { - RUN_TEST(Create, filter); - RUN_TEST_FORCEASYNC_AND_NOT(GetAddress, filter); - RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter); - RUN_TEST_FORCEASYNC_AND_NOT(Reconnect, filter); -} - -void TestTCPSocketPrivateShared::QuitMessageLoop() { - testing_interface_->QuitMessageLoop(instance_->pp_instance()); -} - -std::string TestTCPSocketPrivateShared::CreateSocket(PP_Resource* socket) { - *socket = tcp_socket_private_interface_->Create(instance_->pp_instance()); - if (0 == *socket) - return "PPB_TCPSocket_Private::Create failed"; - if (!tcp_socket_private_interface_->IsTCPSocket(*socket)) - return "PPB_TCPSocket_Private::IsTCPSocket failed"; - PASS(); -} - -std::string TestTCPSocketPrivateShared::SyncConnect(PP_Resource socket, - const char* host, - int port) { - TestCompletionCallback callback(instance_->pp_instance(), force_async_); - - int32_t rv = tcp_socket_private_interface_->Connect( - socket, host, port, - static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); - - if (force_async_ && rv != PP_OK_COMPLETIONPENDING) - return ReportError("PPB_TCPSocket_Private::Connect force_async", rv); - if (rv == PP_OK_COMPLETIONPENDING) - rv = callback.WaitForResult(); - if (rv != PP_OK) - return ReportError("PPB_TCPSocket_Private::Connect", rv); - PASS(); -} - -std::string TestTCPSocketPrivateShared::SyncConnectWithNetAddress( - PP_Resource socket, const PP_NetAddress_Private& addr) { - TestCompletionCallback callback(instance_->pp_instance(), force_async_); - - int32_t rv = tcp_socket_private_interface_->ConnectWithNetAddress( - socket, &addr, - static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); - - if (force_async_ && rv != PP_OK_COMPLETIONPENDING) - return ReportError( - "PPB_TCPSocket_Private::ConnectWithNetAddress force_async", rv); - if (rv == PP_OK_COMPLETIONPENDING) - rv = callback.WaitForResult(); - if (rv != PP_OK) - return ReportError("PPB_TCPSocket_Private::ConnectWithNetAddress", rv); - PASS(); -} - -std::string TestTCPSocketPrivateShared::SyncSSLHandshake(PP_Resource socket, - const char* host, - int port) { - TestCompletionCallback callback(instance_->pp_instance(), force_async_); - - int32_t rv = tcp_socket_private_interface_->SSLHandshake( - socket, host, port, - static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); - - if (force_async_ && rv != PP_OK_COMPLETIONPENDING) - return ReportError("PPB_TCPSocket_Private::SSLHandshake force_async", rv); - if (rv == PP_OK_COMPLETIONPENDING) - rv = callback.WaitForResult(); - if (rv != PP_OK) - return ReportError("PPB_TCPSocket_Private::SSLHandshake", rv); - PASS(); -} - -std::string TestTCPSocketPrivateShared::SyncRead(PP_Resource socket, - char* buffer, - int32_t num_bytes, - int32_t* bytes_read) { - TestCompletionCallback callback(instance_->pp_instance(), force_async_); - - int32_t rv = tcp_socket_private_interface_->Read( - socket, buffer, num_bytes, - static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); - - if (force_async_ && rv != PP_OK_COMPLETIONPENDING) - return ReportError("PPB_TCPSocket_Private::Read force_async", rv); - if (rv == PP_OK_COMPLETIONPENDING) - rv = callback.WaitForResult(); - - if (num_bytes != rv) - return ReportError("PPB_TCPSocket_Private::Read", rv); - - *bytes_read = rv; - PASS(); -} - -std::string TestTCPSocketPrivateShared::SyncWrite(PP_Resource socket, - const char* buffer, - int32_t num_bytes, - int32_t* bytes_wrote) { - TestCompletionCallback callback(instance_->pp_instance(), force_async_); - int32_t rv = tcp_socket_private_interface_->Write( - socket, buffer, num_bytes, - static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); - - if (force_async_ && rv != PP_OK_COMPLETIONPENDING) - return ReportError("PPB_TCPSocket_Private::Write force_async", rv); - if (rv == PP_OK_COMPLETIONPENDING) - rv = callback.WaitForResult(); - if (num_bytes != rv) - return ReportError("PPB_TCPSocket_Private::Write", rv); - - *bytes_wrote = rv; - PASS(); -} - -std::string TestTCPSocketPrivateShared::CheckHTTPResponse( - PP_Resource socket, - const std::string& request, - const std::string& response) { - int32_t rv; - std::string error_message; - - error_message = SyncWrite(socket, request.c_str(), request.size(), &rv); - if (!error_message.empty()) - return error_message; - - std::vector<char> response_buffer(response.size()); - error_message = SyncRead(socket, &response_buffer[0], response.size(), &rv); - if (!error_message.empty()) - return error_message; - - std::string actual_response(&response_buffer[0], rv); - - if (response != actual_response) - return "CheckHTTPResponse failed, expected: " + response + - ", actual: " + actual_response; - PASS(); -} - -std::string TestTCPSocketPrivateShared::TestCreate() { - PP_Resource socket = tcp_socket_private_interface_->Create(0); - if (0 != socket) - return "PPB_TCPSocket_Private::Create returns valid socket " \ - "for invalid instance"; - - return CreateSocket(&socket); -} - -std::string TestTCPSocketPrivateShared::TestGetAddress() { - PP_Resource socket; - std::string error_message; - - error_message = CreateSocket(&socket); - if (!error_message.empty()) - return error_message; - - error_message = SyncConnect(socket, kHost, kPort); - if (!error_message.empty()) - return error_message; - - PP_NetAddress_Private local_address, remote_address; - - if (PP_TRUE != tcp_socket_private_interface_->GetLocalAddress( - socket, &local_address)) - return "PPB_TCPSocketPrivate::GetLocalAddress failed"; - if (PP_TRUE != tcp_socket_private_interface_->GetRemoteAddress( - socket, &remote_address)) - return "PPB_TCPSocketPrivate::GetRemoteAddress failed"; - - tcp_socket_private_interface_->Disconnect(socket); - - PASS(); -} - -std::string TestTCPSocketPrivateShared::TestConnect() { - PP_Resource socket; - std::string error_message; - - error_message = CreateSocket(&socket); - if (!error_message.empty()) - return error_message; - error_message = SyncConnect(socket, kHost, kPort); - if (!error_message.empty()) - return error_message; - error_message = SyncSSLHandshake(socket, kHost, kPort); - if (!error_message.empty()) - return error_message; - error_message = - CheckHTTPResponse(socket, "GET /robots.txt\r\n", "HTTP/1.0 200 OK"); - if (!error_message.empty()) - return error_message; - tcp_socket_private_interface_->Disconnect(socket); - - PASS(); -} - -std::string TestTCPSocketPrivateShared::TestReconnect() { - PP_Resource socket; - std::string error_message; - - error_message = CreateSocket(&socket); - if (!error_message.empty()) - return error_message; - error_message = SyncConnect(socket, kHost, kPort); - if (!error_message.empty()) - return error_message; - error_message = SyncSSLHandshake(socket, kHost, kPort); - if (!error_message.empty()) - return error_message; - - PP_NetAddress_Private remote_address; - if (PP_TRUE != - tcp_socket_private_interface_->GetRemoteAddress(socket, - &remote_address)) - return "PPB_TCPSocketPrivate::GetRemoteAddress failed"; - tcp_socket_private_interface_->Disconnect(socket); - - error_message = CreateSocket(&socket); - if (!error_message.empty()) - return error_message; - error_message = SyncConnectWithNetAddress(socket, remote_address); - if (!error_message.empty()) - return error_message; - error_message = SyncSSLHandshake(socket, kHost, kPort); - if (!error_message.empty()) - return error_message; - error_message = - CheckHTTPResponse(socket, "GET /robots.txt\r\n", "HTTP/1.0 200 OK"); - if (!error_message.empty()) - return error_message; - tcp_socket_private_interface_->Disconnect(socket); - - PASS(); -} diff --git a/ppapi/tests/test_tcp_socket_private_shared.h b/ppapi/tests/test_tcp_socket_private_shared.h deleted file mode 100644 index 72b43b8..0000000 --- a/ppapi/tests/test_tcp_socket_private_shared.h +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef PPAPI_TESTS_TEST_TCP_SOCKET_PRIVATE_SHARED_H_ -#define PPAPI_TESTS_TEST_TCP_SOCKET_PRIVATE_SHARED_H_ - -#include <string> - -#include "ppapi/c/pp_stdint.h" -#include "ppapi/cpp/private/tcp_socket_private.h" -#include "ppapi/tests/test_case.h" - -class TestTCPSocketPrivateShared : public TestCase { - public: - explicit TestTCPSocketPrivateShared(TestingInstance* instance); - - // TestCase implementation. - virtual bool Init(); - virtual void RunTests(const std::string& filter); - - void QuitMessageLoop(); - - private: - static const char* const kHost; - static const int kPort = 443; - - std::string CreateSocket(PP_Resource* socket); - std::string SyncConnect(PP_Resource socket, const char* host, int port); - std::string SyncConnectWithNetAddress(PP_Resource socket, - const PP_NetAddress_Private& addr); - std::string SyncSSLHandshake(PP_Resource socket, const char* host, int port); - std::string SyncRead(PP_Resource socket, char* buffer, int32_t num_bytes, - int32_t* bytes_read); - std::string SyncWrite(PP_Resource socket, const char* buffer, - int32_t num_bytes, int32_t* bytes_wrote); - std::string CheckHTTPResponse(PP_Resource socket, - const std::string& request, - const std::string& response); - - std::string TestCreate(); - std::string TestGetAddress(); - std::string TestConnect(); - std::string TestReconnect(); - - const PPB_TCPSocket_Private* tcp_socket_private_interface_; -}; - -#endif // PPAPI_TESTS_TEST_TCP_SOCKET_PRIVATE_SHARED_H_ diff --git a/ppapi/tests/test_udp_socket_private_shared.cc b/ppapi/tests/test_udp_socket_private_shared.cc deleted file mode 100644 index 73c7523..0000000 --- a/ppapi/tests/test_udp_socket_private_shared.cc +++ /dev/null @@ -1,182 +0,0 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include <string.h> - -#include "ppapi/cpp/module.h" -#include "ppapi/tests/test_udp_socket_private_shared.h" -#include "ppapi/tests/test_utils.h" -#include "ppapi/tests/testing_instance.h" - -REGISTER_TEST_CASE(UDPSocketPrivateShared); - -// TODO(ygorshenin): get rid of using external server in tests, -// http://crbug.com/105863 -const char* const TestUDPSocketPrivateShared::kHost = "www.google.com"; - -TestUDPSocketPrivateShared::TestUDPSocketPrivateShared( - TestingInstance* instance) - : TestCase(instance), - tcp_socket_private_interface_(NULL), - udp_socket_private_interface_(NULL) { -} - -bool TestUDPSocketPrivateShared::Init() { - tcp_socket_private_interface_ = - reinterpret_cast<PPB_TCPSocket_Private const*>( - pp::Module::Get()->GetBrowserInterface( - PPB_TCPSOCKET_PRIVATE_INTERFACE)); - if (!tcp_socket_private_interface_) - instance_->AppendError("TCPSocketPrivate interface not available"); - - udp_socket_private_interface_ = - reinterpret_cast<PPB_UDPSocket_Private const*>( - pp::Module::Get()->GetBrowserInterface( - PPB_UDPSOCKET_PRIVATE_INTERFACE)); - if (!udp_socket_private_interface_) - instance_->AppendError("UDPSocketPrivate interface not available"); - - return tcp_socket_private_interface_ && udp_socket_private_interface_ && - InitTestingInterface(); -} - -void TestUDPSocketPrivateShared::RunTests(const std::string& filter) { - RUN_TEST(Create, filter); - RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter); -} - -void TestUDPSocketPrivateShared::QuitMessageLoop() { - testing_interface_->QuitMessageLoop(instance_->pp_instance()); -} - -std::string TestUDPSocketPrivateShared::GenerateNetAddress( - PP_Resource* socket, PP_NetAddress_Private* address) { - *socket = tcp_socket_private_interface_->Create(instance_->pp_instance()); - if (0 == *socket) - return "PPB_TCPSocket_Private::Create failed"; - - TestCompletionCallback callback(instance_->pp_instance(), force_async_); - int32_t rv = tcp_socket_private_interface_->Connect( - *socket, kHost, kPort, - static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); - if (force_async_ && rv != PP_OK_COMPLETIONPENDING) - return ReportError("PPB_TCPSocket_Private::Connect force_async", rv); - if (rv == PP_OK_COMPLETIONPENDING) - rv = callback.WaitForResult(); - if (rv != PP_OK) - return ReportError("PPB_TCPSocket_Private::Connect", rv); - - rv = tcp_socket_private_interface_->GetLocalAddress(*socket, address); - if (rv != PP_TRUE) - return ReportError("PPB_TCPSocket_Private::GetLocalAddress", rv); - - PASS(); -} - -std::string TestUDPSocketPrivateShared::CreateAndBindUDPSocket( - const PP_NetAddress_Private *address, - PP_Resource *socket) { - *socket = udp_socket_private_interface_->Create(instance_->pp_instance()); - if (0 == *socket) - return "PPB_UDPSocket_Private::Create failed"; - if (!udp_socket_private_interface_->IsUDPSocket(*socket)) - return "PPB_UDPSocket_Private::IsUDPSocket failed"; - - TestCompletionCallback callback(instance_->pp_instance(), force_async_); - int32_t rv = udp_socket_private_interface_->Bind( - *socket, address, - static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); - - if (force_async_ && rv != PP_OK_COMPLETIONPENDING) - return ReportError("PPB_UDPSocket_Private::Bind force_async", rv); - if (rv == PP_OK_COMPLETIONPENDING) - rv = callback.WaitForResult(); - if (rv != PP_OK) - return ReportError("PPB_UDPSocket_Private::Bind", rv); - - PASS(); -} - -std::string TestUDPSocketPrivateShared::TestCreate() { - PP_Resource udp_socket; - std::string error_message; - - udp_socket = udp_socket_private_interface_->Create(0); - if (0 != udp_socket) - return "PPB_UDPSocket_Private::Create returns valid socket " \ - "for invalid instance"; - - udp_socket = udp_socket_private_interface_->Create(instance_->pp_instance()); - if (0 == udp_socket) - return "PPB_UDPSocket_Private::Create failed"; - if (!udp_socket_private_interface_->IsUDPSocket(udp_socket)) - return "PPB_UDPSocket_Private::IsUDPSocket failed"; - - PASS(); -} - -std::string TestUDPSocketPrivateShared::TestConnect() { - PP_NetAddress_Private server_address, client_address; - PP_Resource tcp_socket_server, tcp_socket_client; - std::string error_message; - - error_message = GenerateNetAddress(&tcp_socket_server, &server_address); - if (!error_message.empty()) - return error_message; - error_message = GenerateNetAddress(&tcp_socket_client, &client_address); - if (error_message.empty()) - return error_message; - - PP_Resource socket_server, socket_client; - error_message = CreateAndBindUDPSocket(&server_address, &socket_server); - if (error_message.empty()) - return error_message; - error_message = CreateAndBindUDPSocket(&client_address, &socket_client); - if (error_message.empty()) - return error_message; - - static const char* const kMessage = - "Simple message that will be sent via UDP"; - static const size_t kMessageBufferSize = 1024; - char message_buffer[kMessageBufferSize]; - - TestCompletionCallback write_cb(instance_->pp_instance(), force_async_); - int32_t write_rv = udp_socket_private_interface_->SendTo( - socket_client, - kMessage, - strlen(kMessage), - &server_address, - static_cast<pp::CompletionCallback>(write_cb).pp_completion_callback()); - if (force_async_ && write_rv != PP_OK_COMPLETIONPENDING) - return ReportError("PPB_UDPSocket_Private::SendTo force_async", write_rv); - - TestCompletionCallback read_cb(instance_->pp_instance(), force_async_); - int32_t read_rv = udp_socket_private_interface_->RecvFrom( - socket_server, - message_buffer, - strlen(kMessage), - static_cast<pp::CompletionCallback>(read_cb).pp_completion_callback()); - if (force_async_ && read_rv != PP_OK_COMPLETIONPENDING) - return ReportError("PPB_UDPSocket_Private::RecvFrom force_async", read_rv); - - if (read_rv == PP_OK_COMPLETIONPENDING) - read_rv = read_cb.WaitForResult(); - if (read_rv < 0 || strlen(kMessage) != static_cast<size_t>(read_rv)) - return ReportError("PPB_UDPSocket_Private::RecvFrom", read_rv); - - if (write_rv == PP_OK_COMPLETIONPENDING) - write_rv = write_cb.WaitForResult(); - if (write_rv < 0 || strlen(kMessage) != static_cast<size_t>(write_rv)) - return ReportError("PPB_UDPSocket_Private::SendTo", write_rv); - - ASSERT_EQ(0, strncmp(kMessage, message_buffer, strlen(kMessage))); - - udp_socket_private_interface_->Close(socket_server); - udp_socket_private_interface_->Close(socket_client); - - tcp_socket_private_interface_->Disconnect(tcp_socket_server); - tcp_socket_private_interface_->Disconnect(tcp_socket_client); - - PASS(); -} diff --git a/ppapi/tests/test_udp_socket_private_shared.h b/ppapi/tests/test_udp_socket_private_shared.h deleted file mode 100644 index 8104d01..0000000 --- a/ppapi/tests/test_udp_socket_private_shared.h +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef PPAPI_TESTS_TEST_UDP_SOCKET_PRIVATE_SHARED_H_ -#define PPAPI_TESTS_TEST_UDP_SOCKET_PRIVATE_SHARED_H_ - -#include "ppapi/cpp/private/tcp_socket_private.h" -#include "ppapi/cpp/private/udp_socket_private.h" -#include "ppapi/tests/test_case.h" - -class TestUDPSocketPrivateShared : public TestCase { - public: - explicit TestUDPSocketPrivateShared(TestingInstance* instance); - - // TestCase implementation. - virtual bool Init(); - virtual void RunTests(const std::string& filter); - - void QuitMessageLoop(); - - private: - static const char* const kHost; - static const int kPort = 80; - - // Creates tcp_socket and connects to www.google.com:80. After that, - // stores into |address| local address and returns created - // tcp_socket. This is a way to create |PP_NetAddress_Private| - // structure filled with local IP and some free port. - std::string GenerateNetAddress(PP_Resource* socket, - PP_NetAddress_Private* address); - std::string CreateAndBindUDPSocket(const PP_NetAddress_Private *address, - PP_Resource *socket); - - std::string TestCreate(); - std::string TestConnect(); - - const PPB_TCPSocket_Private* tcp_socket_private_interface_; - const PPB_UDPSocket_Private* udp_socket_private_interface_; -}; - -#endif // PPAPI_TESTS_TEST_UDP_SOCKET_PRIVATE_SHARED_H_ diff --git a/ppapi/thunk/ppb_tcp_socket_private_api.h b/ppapi/thunk/ppb_tcp_socket_private_api.h index 18792ae..0483856 100644 --- a/ppapi/thunk/ppb_tcp_socket_private_api.h +++ b/ppapi/thunk/ppb_tcp_socket_private_api.h @@ -6,12 +6,11 @@ #define PPAPI_THUNK_PPB_TCP_SOCKET_PRIVATE_API_H_ #include "ppapi/c/private/ppb_tcp_socket_private.h" -#include "ppapi/thunk/ppapi_thunk_export.h" namespace ppapi { namespace thunk { -class PPAPI_THUNK_EXPORT PPB_TCPSocket_Private_API { +class PPB_TCPSocket_Private_API { public: virtual ~PPB_TCPSocket_Private_API() {} diff --git a/ppapi/thunk/ppb_udp_socket_private_api.h b/ppapi/thunk/ppb_udp_socket_private_api.h index b8a3436..e79b313 100644 --- a/ppapi/thunk/ppb_udp_socket_private_api.h +++ b/ppapi/thunk/ppb_udp_socket_private_api.h @@ -6,12 +6,11 @@ #define PPAPI_THUNK_PPB_UDP_SOCKET_PRIVATE_API_H_ #include "ppapi/c/private/ppb_udp_socket_private.h" -#include "ppapi/thunk/ppapi_thunk_export.h" namespace ppapi { namespace thunk { -class PPAPI_THUNK_EXPORT PPB_UDPSocket_Private_API { +class PPB_UDPSocket_Private_API { public: virtual ~PPB_UDPSocket_Private_API() {} |