PPB_TCPSocket_Private/PPB_UDPSocket_Private are exposed to Browser

ppapi/shared_impl/tcp_socket_impl.cc

+// 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/tcp_socket_impl.h"
+
+#include "base/logging.h"
+#include "ppapi/c/pp_errors.h"
+
+namespace ppapi {
+
+const int32_t TCPSocketImpl::kMaxReadSize = 1024 * 1024;
+const int32_t TCPSocketImpl::kMaxWriteSize = 1024 * 1024;
+
+TCPSocketImpl::TCPSocketImpl(const HostResource& resource, uint32 socket_id)
+    : Resource(resource) {
+  Init(socket_id);
+}
+
+TCPSocketImpl::TCPSocketImpl(PP_Instance instance, uint32 socket_id)
+    : Resource(instance) {
+  Init(socket_id);
+}
+
+TCPSocketImpl::~TCPSocketImpl() {
+  Disconnect();

[yzshen1, 2011/11/28 20:59:16]

We cannot call it here -- this calls virtual method.
Besides, you have called it in subclasses.

[ygorshenin, 2011/11/29 18:30:09]

Done.

+}
+
+void TCPSocketImpl::Init(uint32 socket_id) {

[yzshen1, 2011/11/28 20:59:16]

Sort the definitions in the same order as the declarations, please.

[ygorshenin, 2011/11/29 18:30:09]

Done.

+  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, sizeof(local_addr_.data));

[dmichael (off chromium), 2011/11/28 20:38:43]

please use arraysize instead of sizeof. This will protect you if data somehow
became a pointer instead of an array. Same on 43.

[yzshen1, 2011/11/28 20:59:16]

Please add include.

[ygorshenin, 2011/11/29 18:30:09]

Done.

[ygorshenin, 2011/11/29 18:30:09]

Done.

+  remote_addr_.size = 0;
+  memset(remote_addr_.data, 0, sizeof(remote_addr_.data));
+}
+
+thunk::PPB_TCPSocket_Private_API*
+TCPSocketImpl::AsPPB_TCPSocket_Private_API() {
+  return this;
+}
+
+int32_t TCPSocketImpl::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 TCPSocketImpl::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 TCPSocketImpl::GetLocalAddress(PP_NetAddress_Private* local_addr) {
+  if (!IsConnected() || !local_addr)
+    return PP_FALSE;
+
+  *local_addr = local_addr_;
+  return PP_TRUE;
+}
+
+PP_Bool TCPSocketImpl::GetRemoteAddress(PP_NetAddress_Private* remote_addr) {
+  if (!IsConnected() || !remote_addr)
+    return PP_FALSE;
+
+  *remote_addr = remote_addr_;
+  return PP_TRUE;
+}
+
+int32_t TCPSocketImpl::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 TCPSocketImpl::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)

[dmichael (off chromium), 2011/11/28 20:38:43]

A plugin will eventually be able to provide a completion callbacks with a null
func to mean 'block until completion' off the main thread. As written, your code
would allow another read to happen in that case. You should probably use a
different indicator for whether a read or handshake is in progress (here and
elsewhere).

[yzshen1, 2011/11/28 22:11:14]

Dave: with line 129-130, it won't get into this state.

Since I am the author of this code, I will be happy to make the change to enable
'block until completion' off the main thread.

But I am not sure about what should be changed. For example, what should be done
in OnReadCompleted() to notify the plugin in an off-main-thread-blocking
scenario. Would you please explain that to me or point me to relevant code/doc?
Thanks!

[dmichael (off chromium), 2011/11/28 22:21:27]

There's a lot of work still to be done for blocking completion callbacks; it
doesn't make sense to add that support here yet. I'm intending to implement a
completion callback helper at some point that will use a condition variable to
wake up the caller. There's going to be 1 big lock for the proxy, which is also
not implemented yet.

I agree, as-is, the callback function will work to signal if an operation is
in-progress. But I'm afraid it's a subtlety that will be missed later when
implementing blocking completion callbacks. And as it's written right now, it
could be a little confusing. A null 'func' has two possible meanings here:
blocking completion callback, or the associated operation is not in-progress.

If you think I'm being overly pedantic, please stick a TODO (put my name on it
if you like) to use some other strategy for determining if an operation is in
progress. This will be important later, but it doesn't need to hold up the CL.

[ygorshenin, 2011/11/29 18:30:09]

Added TODO comment.

+    return PP_ERROR_INPROGRESS;
+
+  read_buffer_ = buffer;
+  bytes_to_read_ = std::min(bytes_to_read, kMaxReadSize);

[yzshen1, 2011/11/28 20:59:16]

Please add include.

[ygorshenin, 2011/11/29 18:30:09]

Done.

+  read_callback_ = callback;
+
+  // Send the request, the browser will call us back via ReadACK.
+  SendRead(bytes_to_read_);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t TCPSocketImpl::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 TCPSocketImpl::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 TCPSocketImpl::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 TCPSocketImpl::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 TCPSocketImpl::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 TCPSocketImpl::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 TCPSocketImpl::IsConnected() const {
+  return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED;
+}
+
+void TCPSocketImpl::PostAbortAndClearIfNecessary(
+    PP_CompletionCallback* callback) {
+  DCHECK(callback);
+
+  if (callback->func) {
+    PostAbort(*callback);
+    *callback = PP_BlockUntilComplete();
+  }
+}
+
+}  // namespace ppapi