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

content/browser/renderer_host/pepper/pepper_tcp_socket.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 "content/browser/renderer_host/pepper/pepper_tcp_socket.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 178 matching lines @@
     NOTREACHED();
     data_size = ppapi::TCPSocketPrivateImpl::kMaxWriteSize;
   }
 
   write_buffer_base_ = new net::IOBuffer(data_size);
   memcpy(write_buffer_base_->data(), data.data(), data_size);
   write_buffer_ = new net::DrainableIOBuffer(write_buffer_base_, data_size);
   DoWrite();
 }
 
+void PepperTCPSocket::SetBoolOption(uint32_t name, bool value) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(socket_.get());
+
+  switch (name) {
+    case PP_TCPSOCKETOPTION_NO_DELAY:
+      if (!IsSsl()) {
+        net::TCPClientSocket* tcp_socket =
+            static_cast<net::TCPClientSocket*>(socket_.get());
+        SendSetBoolOptionACK(tcp_socket->SetNoDelay(value));
+      } else {
+        SendSetBoolOptionACK(false);
+      }
+      return;
+    default:
+      break;
+  }
+
+  NOTREACHED();
+  SendSetBoolOptionACK(false);
+}
+
 void PepperTCPSocket::StartConnect(const net::AddressList& addresses) {
   DCHECK(connection_state_ == CONNECT_IN_PROGRESS);
 
-  socket_.reset(
-      new net::TCPClientSocket(addresses, NULL, net::NetLog::Source()));
+  socket_.reset(new net::TCPClientSocket(addresses, NULL,
+                                         net::NetLog::Source()));
   int result = socket_->Connect(
       base::Bind(&PepperTCPSocket::OnConnectCompleted,
                  base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnConnectCompleted(result);
 }
 
 void PepperTCPSocket::SendConnectACKError() {
   manager_->Send(new PpapiMsg_PPBTCPSocket_ConnectACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false,
@@ skipping 82 matching lines @@
       GetCertificateFields(*ssl_info.cert, &certificate_fields);
   }
   manager_->Send(new PpapiMsg_PPBTCPSocket_SSLHandshakeACK(
       routing_id_,
       plugin_dispatcher_id_,
       socket_id_,
       succeeded,
       certificate_fields));
 }
 
+void PepperTCPSocket::SendSetBoolOptionACK(bool succeeded) {
+  manager_->Send(new PpapiMsg_PPBTCPSocket_SetBoolOptionACK(
+      routing_id_, plugin_dispatcher_id_, socket_id_, succeeded));
+}
+
 void PepperTCPSocket::OnResolveCompleted(int result) {
   DCHECK(connection_state_ == CONNECT_IN_PROGRESS);
 
   if (result != net::OK) {
     SendConnectACKError();
     connection_state_ = BEFORE_CONNECT;
     return;
   }
 
   StartConnect(address_list_);
@@ skipping 82 matching lines @@
   }
 
   write_buffer_ = NULL;
   write_buffer_base_ = NULL;
 }
 
 bool PepperTCPSocket::IsConnected() const {
   return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED;
 }
 
+bool PepperTCPSocket::IsSsl() const {
+ return connection_state_ == SSL_HANDSHAKE_IN_PROGRESS ||
+     connection_state_ == SSL_CONNECTED ||
+     connection_state_ == SSL_HANDSHAKE_FAILED;
+}
+
 void PepperTCPSocket::DoWrite() {
   DCHECK(write_buffer_base_.get());
   DCHECK(write_buffer_.get());
   DCHECK_GT(write_buffer_->BytesRemaining(), 0);
 
   int result = socket_->Write(write_buffer_, write_buffer_->BytesRemaining(),
                               base::Bind(&PepperTCPSocket::OnWriteCompleted,
                                          base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnWriteCompleted(result);
 }
 
 }  // namespace content