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

ppapi/tests/test_tcp_socket_private.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/tests/test_tcp_socket_private.h"
 
 #include <stdlib.h>
 
 #include "ppapi/cpp/private/tcp_socket_private.h"
 #include "ppapi/tests/testing_instance.h"
@@ skipping 33 matching lines @@
   ssl_port_ = instance_->ssl_server_port();
 
   return true;
 }
 
 void TestTCPSocketPrivate::RunTests(const std::string& filter) {
   RUN_TEST_FORCEASYNC_AND_NOT(Basic, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(ReadWrite, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(ReadWriteSSL, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(ConnectAddress, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(SetOption, filter);
 }
 
 std::string TestTCPSocketPrivate::TestBasic() {
   pp::TCPSocketPrivate socket(instance_);
   TestCompletionCallback cb(instance_->pp_instance(), force_async_);
 
   int32_t rv = socket.Connect(host_.c_str(), port_, cb);
   ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = cb.WaitForResult();
@@ skipping 89 matching lines @@
   ASSERT_EQ(PP_OK, WriteStringToSocket(&socket, "GET / HTTP/1.0\r\n\r\n"));
   std::string s;
   ASSERT_EQ(PP_OK, ReadFirstLineFromSocket(&socket, &s));
   ASSERT_TRUE(ValidateHttpResponse(s));
 
   socket.Disconnect();
 
   PASS();
 }
 
+std::string TestTCPSocketPrivate::TestSetOption() {
+  pp::TCPSocketPrivate socket(instance_);
+  TestCompletionCallback cb(instance_->pp_instance(), force_async_);
+
+  int32_t rv = socket.SetOption(PP_TCPSOCKETOPTION_NO_DELAY, true, cb);
+  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = cb.WaitForResult();
+  ASSERT_EQ(PP_ERROR_FAILED, rv);
+
+  rv = socket.Connect(host_.c_str(), port_, cb);
+  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = cb.WaitForResult();
+  ASSERT_EQ(PP_OK, rv);
+
+  rv = socket.SetOption(PP_TCPSOCKETOPTION_NO_DELAY, true, cb);
+  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = cb.WaitForResult();
+  ASSERT_EQ(PP_OK, rv);
+
+  rv = socket.SetOption(PP_TCPSOCKETOPTION_INVALID, true, cb);
+  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = cb.WaitForResult();
+  ASSERT_EQ(PP_ERROR_BADARGUMENT, rv);
+
+  socket.Disconnect();
+
+  PASS();
+}
+
 int32_t TestTCPSocketPrivate::ReadFirstLineFromSocket(
     pp::TCPSocketPrivate* socket,
     std::string* s) {
   char buffer[10000];
 
   s->clear();
   // Make sure we don't just hang if |Read()| spews.
   while (s->size() < 1000000) {
     TestCompletionCallback cb(instance_->pp_instance(), force_async_);
     int32_t rv = socket->Read(buffer, sizeof(buffer), cb);
@@ skipping 29 matching lines @@
     if (rv < 0)
       return rv;
     if (rv == 0)
       return PP_ERROR_FAILED;
     written += rv;
   }
   if (written != s.size())
     return PP_ERROR_FAILED;
   return PP_OK;
 }