diff options
author | dpolukhin@chromium.org <dpolukhin@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2011-12-02 14:29:07 +0000 |
---|---|---|
committer | dpolukhin@chromium.org <dpolukhin@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2011-12-02 14:29:07 +0000 |
commit | ed966587d28db59eb131487bc097d0f4a19a47a4 (patch) | |
tree | 386b9f3f78c09af7a37529b3566416a13a7d2ba2 /ppapi | |
parent | 64576b675e4fc0e2d2eaa4b669df8685b0f7a476 (diff) | |
download | chromium_src-ed966587d28db59eb131487bc097d0f4a19a47a4.zip chromium_src-ed966587d28db59eb131487bc097d0f4a19a47a4.tar.gz chromium_src-ed966587d28db59eb131487bc097d0f4a19a47a4.tar.bz2 |
Landing 8688002: PPB_TCPSocket_Private/PPB_UDPSocket_Private are exposed to Browser
Review URL: http://codereview.chromium.org/8688002
Patch from Yuri Gorshenin <ygorshenin@chromium.org>.
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@112693 0039d316-1c4b-4281-b951-d872f2087c98
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, 1320 insertions, 558 deletions
diff --git a/ppapi/ppapi_shared.gypi b/ppapi/ppapi_shared.gypi index 84673de..5303b49 100644 --- a/ppapi/ppapi_shared.gypi +++ b/ppapi/ppapi_shared.gypi @@ -94,6 +94,11 @@ '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 f715443..2bd9583 100644 --- a/ppapi/ppapi_sources.gypi +++ b/ppapi/ppapi_sources.gypi @@ -253,10 +253,14 @@ '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 4613784..b943889 100644 --- a/ppapi/proxy/ppb_tcp_socket_private_proxy.cc +++ b/ppapi/proxy/ppb_tcp_socket_private_proxy.cc @@ -4,143 +4,46 @@ #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, TCPSocket*> IDToSocketMap; +typedef std::map<uint32, TCPSocketPrivateImpl*> IDToSocketMap; IDToSocketMap* g_id_to_socket = NULL; -void AbortCallback(PP_CompletionCallback callback) { - if (callback.func) - PP_RunCompletionCallback(&callback, PP_ERROR_ABORTED); -} - -} // namespace - -class TCPSocket : public PPB_TCPSocket_Private_API, - public Resource { +class TCPSocket : public TCPSocketPrivateImpl { public: TCPSocket(const HostResource& resource, uint32 socket_id); virtual ~TCPSocket(); - // 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); + 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; private: - 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_; + void SendToBrowser(IPC::Message* msg); DISALLOW_COPY_AND_ASSIGN(TCPSocket); }; TCPSocket::TCPSocket(const HostResource& resource, uint32 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)); - + : TCPSocketPrivateImpl(resource, socket_id) { if (!g_id_to_socket) g_id_to_socket = new IDToSocketMap(); DCHECK(g_id_to_socket->find(socket_id) == g_id_to_socket->end()); @@ -151,236 +54,44 @@ TCPSocket::~TCPSocket() { Disconnect(); } -PPB_TCPSocket_Private_API* TCPSocket::AsPPB_TCPSocket_Private_API() { - return this; +void TCPSocket::SendConnect(const std::string& host, uint16_t port) { + SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Connect(socket_id_, host, port)); } -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::SendConnectWithNetAddress(const PP_NetAddress_Private& addr) { + SendToBrowser( + new PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress(socket_id_, addr)); } -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::SendSSLHandshake(const std::string& server_name, + uint16_t server_port) { + SendToBrowser(new PpapiHostMsg_PPBTCPSocket_SSLHandshake( + socket_id_, server_name, server_port)); } -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::SendRead(int32_t bytes_to_read) { + SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Read(socket_id_, bytes_to_read)); } -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::SendWrite(const std::string& buffer) { + SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Write(socket_id_, buffer)); } -void TCPSocket::Disconnect() { - if (connection_state_ == DISCONNECTED) - return; - - connection_state_ = DISCONNECTED; +void TCPSocket::SendDisconnect() { // 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_); - - 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::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(); - } + SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Disconnect(socket_id_)); } -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::SendToBrowser(IPC::Message* msg) { + PluginDispatcher::GetForResource(this)->SendToBrowser(msg); } -void TCPSocket::PostAbortAndClearIfNecessary( - PP_CompletionCallback* callback) { - DCHECK(callback); +} // namespace - 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 ec89fe2..3e50b9f 100644 --- a/ppapi/proxy/ppb_tcp_socket_private_proxy.h +++ b/ppapi/proxy/ppb_tcp_socket_private_proxy.h @@ -17,13 +17,6 @@ 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 1347049..444a7da 100644 --- a/ppapi/proxy/ppb_udp_socket_private_proxy.cc +++ b/ppapi/proxy/ppb_udp_socket_private_proxy.cc @@ -4,113 +4,43 @@ #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 { -class UDPSocket; - -typedef std::map<uint32, UDPSocket*> IDToSocketMap; +typedef std::map<uint32, UDPSocketPrivateImpl*> IDToSocketMap; IDToSocketMap* g_id_to_socket = NULL; -void AbortCallback(PP_CompletionCallback callback) { - if (callback.func) - PP_RunCompletionCallback(&callback, PP_ERROR_ABORTED); -} - -class UDPSocket : public PPB_UDPSocket_Private_API, - public Resource { +class UDPSocket : public UDPSocketPrivateImpl { public: UDPSocket(const HostResource& resource, uint32 socket_id); virtual ~UDPSocket(); - // 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); + 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; private: - 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_; + void SendToBrowser(IPC::Message* msg); DISALLOW_COPY_AND_ASSIGN(UDPSocket); }; UDPSocket::UDPSocket(const HostResource& resource, uint32 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)); - + : UDPSocketPrivateImpl(resource, socket_id) { if (!g_id_to_socket) g_id_to_socket = new IDToSocketMap(); DCHECK(g_id_to_socket->find(socket_id) == g_id_to_socket->end()); @@ -121,160 +51,35 @@ UDPSocket::~UDPSocket() { Close(); } -PPB_UDPSocket_Private_API* UDPSocket::AsPPB_UDPSocket_Private_API() { - return this; +void UDPSocket::SendBind(const PP_NetAddress_Private& addr) { + SendToBrowser(new PpapiHostMsg_PPBUDPSocket_Bind(socket_id_, addr)); } -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::SendRecvFrom(int32_t num_bytes) { + SendToBrowser(new PpapiHostMsg_PPBUDPSocket_RecvFrom(socket_id_, num_bytes)); } -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::SendSendTo(const std::string& data, + const PP_NetAddress_Private& addr) { + SendToBrowser(new PpapiHostMsg_PPBUDPSocket_SendTo(socket_id_, data, addr)); } -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 +void UDPSocket::SendClose() { + // 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_); - - GetDispatcher()->SendToBrowser( - new PpapiHostMsg_PPBUDPSocket_Close(socket_id_)); - socket_id_ = 0; - - PostAbortAndClearIfNecessary(&bind_callback_); - PostAbortAndClearIfNecessary(&recvfrom_callback_); - PostAbortAndClearIfNecessary(&sendto_callback_); + SendToBrowser(new PpapiHostMsg_PPBUDPSocket_Close(socket_id_)); } -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); +void UDPSocket::SendToBrowser(IPC::Message* msg) { + PluginDispatcher::GetForResource(this)->SendToBrowser(msg); } -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 337cf6b..c6c9e68 100644 --- a/ppapi/proxy/ppb_udp_socket_private_proxy.h +++ b/ppapi/proxy/ppb_udp_socket_private_proxy.h @@ -16,13 +16,6 @@ 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); @@ -57,4 +50,3 @@ 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 new file mode 100644 index 0000000..7ec1535 --- /dev/null +++ b/ppapi/shared_impl/private/tcp_socket_private_impl.cc @@ -0,0 +1,289 @@ +// 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 new file mode 100644 index 0000000..095f155 --- /dev/null +++ b/ppapi/shared_impl/private/tcp_socket_private_impl.h @@ -0,0 +1,116 @@ +// 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 new file mode 100644 index 0000000..388d159 --- /dev/null +++ b/ppapi/shared_impl/private/udp_socket_private_impl.cc @@ -0,0 +1,209 @@ +// 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 new file mode 100644 index 0000000..0f06e06 --- /dev/null +++ b/ppapi/shared_impl/private/udp_socket_private_impl.h @@ -0,0 +1,92 @@ +// 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 new file mode 100644 index 0000000..7ca3666 --- /dev/null +++ b/ppapi/tests/test_tcp_socket_private_shared.cc @@ -0,0 +1,271 @@ +// 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 new file mode 100644 index 0000000..72b43b8 --- /dev/null +++ b/ppapi/tests/test_tcp_socket_private_shared.h @@ -0,0 +1,49 @@ +// 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 new file mode 100644 index 0000000..73c7523 --- /dev/null +++ b/ppapi/tests/test_udp_socket_private_shared.cc @@ -0,0 +1,182 @@ +// 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 new file mode 100644 index 0000000..8104d01 --- /dev/null +++ b/ppapi/tests/test_udp_socket_private_shared.h @@ -0,0 +1,42 @@ +// 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 0483856..18792ae 100644 --- a/ppapi/thunk/ppb_tcp_socket_private_api.h +++ b/ppapi/thunk/ppb_tcp_socket_private_api.h @@ -6,11 +6,12 @@ #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 PPB_TCPSocket_Private_API { +class PPAPI_THUNK_EXPORT 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 e79b313..b8a3436 100644 --- a/ppapi/thunk/ppb_udp_socket_private_api.h +++ b/ppapi/thunk/ppb_udp_socket_private_api.h @@ -6,11 +6,12 @@ #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 PPB_UDPSocket_Private_API { +class PPAPI_THUNK_EXPORT PPB_UDPSocket_Private_API { public: virtual ~PPB_UDPSocket_Private_API() {} |