Provide a way to disable Nagle's algorithm on Pepper TCP sockets.

ppapi/shared_impl/private/tcp_socket_private_impl.cc

 // Copyright (c) 2012 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>
 
@@ skipping 194 matching lines @@
 
   connection_state_ = DISCONNECTED;
 
   SendDisconnect();
   socket_id_ = 0;
 
   PostAbortIfNecessary(&connect_callback_);
   PostAbortIfNecessary(&ssl_handshake_callback_);
   PostAbortIfNecessary(&read_callback_);
   PostAbortIfNecessary(&write_callback_);
+  PostAbortIfNecessary(&set_option_callback_);
   read_buffer_ = NULL;
   bytes_to_read_ = -1;
   server_certificate_ = NULL;
 }
 
+int32_t TCPSocketPrivateImpl::SetOption(
+    PP_TCPSocketOption_Private name,
+    const PP_Var& value,
+    scoped_refptr<TrackedCallback> callback) {
+  if (!IsConnected())
+    return PP_ERROR_FAILED;
+  if (TrackedCallback::IsPending(set_option_callback_))
+    return PP_ERROR_INPROGRESS;
+
+  set_option_callback_ = callback;
+
+  switch (name) {
+    case PP_TCPSOCKETOPTION_NO_DELAY:
+      if (value.type != PP_VARTYPE_BOOL)
+        return PP_ERROR_BADARGUMENT;
+      SendSetBoolOption(name, PP_ToBool(value.value.as_bool));
+      return PP_OK_COMPLETIONPENDING;
+    default:
+      return PP_ERROR_BADARGUMENT;
+  }
+}
+
 void TCPSocketPrivateImpl::OnConnectCompleted(
     bool succeeded,
     const PP_NetAddress_Private& local_addr,
     const PP_NetAddress_Private& remote_addr) {
   if (connection_state_ != BEFORE_CONNECT ||
       !TrackedCallback::IsPending(connect_callback_)) {
     NOTREACHED();
     return;
   }
 
@@ skipping 56 matching lines @@
   if (!TrackedCallback::IsPending(write_callback_) ||
       (succeeded && bytes_written < 0)) {
     NOTREACHED();
     return;
   }
 
   write_callback_->Run(
       succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED));
 }
 
+void TCPSocketPrivateImpl::OnSetOptionCompleted(bool succeeded) {
+  if (!TrackedCallback::IsPending(set_option_callback_)) {
+    NOTREACHED();
+    return;
+  }
+
+  set_option_callback_->Run(succeeded ? PP_OK : PP_ERROR_FAILED);
+}
+
 void TCPSocketPrivateImpl::Init(uint32 socket_id) {
   DCHECK(socket_id != 0);
   socket_id_ = socket_id;
   connection_state_ = BEFORE_CONNECT;
   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::PostAbortIfNecessary(
     scoped_refptr<TrackedCallback>* callback) {
   if (TrackedCallback::IsPending(*callback))
     (*callback)->PostAbort();
 }
 
 }  // namespace ppapi