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

ppapi/proxy/ppb_tcp_socket_private_proxy.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/proxy/ppb_tcp_socket_private_proxy.h"
 
 #include <map>
 
 #include "base/logging.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
@@ skipping 28 matching lines @@
   virtual void SendConnectWithNetAddress(
       const PP_NetAddress_Private& addr) OVERRIDE;
   virtual void SendSSLHandshake(
       const std::string& server_name,
       uint16_t server_port,
       const std::vector<std::vector<char> >& trusted_certs,
       const std::vector<std::vector<char> >& untrusted_certs) OVERRIDE;
   virtual void SendRead(int32_t bytes_to_read) OVERRIDE;
   virtual void SendWrite(const std::string& buffer) OVERRIDE;
   virtual void SendDisconnect() OVERRIDE;
+  virtual void SendBoolSocketFeature(int32_t name, bool value) OVERRIDE;

[yzshen1, 2013/02/08 21:51:11]

Please use the enum type instead of int32_t.

[Wez, 2013/02/10 04:47:02]

Done.

 
  private:
   void SendToBrowser(IPC::Message* msg);
 
   DISALLOW_COPY_AND_ASSIGN(TCPSocket);
 };
 
 TCPSocket::TCPSocket(const HostResource& resource, uint32 socket_id)
     : TCPSocketPrivateImpl(resource, socket_id) {
   if (!g_id_to_socket)
@@ skipping 50 matching lines @@
 }
 
 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_);
   SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Disconnect(socket_id_));
 }
 
+void TCPSocket::SendBoolSocketFeature(int32_t name, bool value) {
+  SendToBrowser(new PpapiHostMsg_PPBTCPSocket_SetBoolFeature(
+      socket_id_, name, value));
+}
+
 void TCPSocket::SendToBrowser(IPC::Message* msg) {
   PluginGlobals::Get()->GetBrowserSender()->Send(msg);
 }
 
 }  // namespace
 
 //------------------------------------------------------------------------------
 
 PPB_TCPSocket_Private_Proxy::PPB_TCPSocket_Private_Proxy(Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher) {
@@ skipping 34 matching lines @@
 
 bool PPB_TCPSocket_Private_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_TCPSocket_Private_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ConnectACK,
                         OnMsgConnectACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_SSLHandshakeACK,
                         OnMsgSSLHandshakeACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ReadACK, OnMsgReadACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_WriteACK, OnMsgWriteACK)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_SetBoolFeatureACK,
+                        OnMsgSetBoolFeatureACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PPB_TCPSocket_Private_Proxy::OnMsgConnectACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
     bool succeeded,
     const PP_NetAddress_Private& local_addr,
@@ skipping 46 matching lines @@
   if (!g_id_to_socket) {
     NOTREACHED();
     return;
   }
   IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
   if (iter == g_id_to_socket->end())
     return;
   iter->second->OnWriteCompleted(succeeded, bytes_written);
 }
 
+void PPB_TCPSocket_Private_Proxy::OnMsgSetBoolFeatureACK(
+    uint32 /* plugin_dispatcher_id */,
+    uint32 socket_id,
+    bool succeeded) {
+  if (!g_id_to_socket) {
+    NOTREACHED();
+    return;
+  }
+  IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
+  if (iter == g_id_to_socket->end())
+    return;
+  iter->second->OnSetSocketFeatureCompleted(succeeded);
+}
+
 }  // namespace proxy
 }  // namespace ppapi