summaryrefslogtreecommitdiffstats
path: root/ppapi
diff options
context:
space:
mode:
authordpolukhin@chromium.org <dpolukhin@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>2011-12-02 14:29:07 +0000
committerdpolukhin@chromium.org <dpolukhin@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>2011-12-02 14:29:07 +0000
commited966587d28db59eb131487bc097d0f4a19a47a4 (patch)
tree386b9f3f78c09af7a37529b3566416a13a7d2ba2 /ppapi
parent64576b675e4fc0e2d2eaa4b669df8685b0f7a476 (diff)
downloadchromium_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.gypi5
-rw-r--r--ppapi/ppapi_sources.gypi6
-rw-r--r--ppapi/proxy/ppb_tcp_socket_private_proxy.cc353
-rw-r--r--ppapi/proxy/ppb_tcp_socket_private_proxy.h7
-rw-r--r--ppapi/proxy/ppb_udp_socket_private_proxy.cc243
-rw-r--r--ppapi/proxy/ppb_udp_socket_private_proxy.h8
-rw-r--r--ppapi/shared_impl/private/tcp_socket_private_impl.cc289
-rw-r--r--ppapi/shared_impl/private/tcp_socket_private_impl.h116
-rw-r--r--ppapi/shared_impl/private/udp_socket_private_impl.cc209
-rw-r--r--ppapi/shared_impl/private/udp_socket_private_impl.h92
-rw-r--r--ppapi/tests/test_tcp_socket_private_shared.cc271
-rw-r--r--ppapi/tests/test_tcp_socket_private_shared.h49
-rw-r--r--ppapi/tests/test_udp_socket_private_shared.cc182
-rw-r--r--ppapi/tests/test_udp_socket_private_shared.h42
-rw-r--r--ppapi/thunk/ppb_tcp_socket_private_api.h3
-rw-r--r--ppapi/thunk/ppb_udp_socket_private_api.h3
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() {}