TCPSockets are switched to the new Pepper proxy.

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 <new>
+
 #include "ppapi/cpp/private/tcp_socket_private.h"
+#include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
-#include "ppapi/tests/test_utils.h"
 
 namespace {
 
 // Validates the first line of an HTTP response.
 bool ValidateHttpResponse(const std::string& s) {
   // Just check that it begins with "HTTP/" and ends with a "\r\n".
   return s.size() >= 5 &&
          s.substr(0, 5) == "HTTP/" &&
          s.substr(s.size() - 2) == "\r\n";
 }
@@ skipping 23 matching lines @@
 
   return true;
 }
 
 void TestTCPSocketPrivate::RunTests(const std::string& filter) {
   RUN_CALLBACK_TEST(TestTCPSocketPrivate, Basic, filter);
   RUN_CALLBACK_TEST(TestTCPSocketPrivate, ReadWrite, filter);
   RUN_CALLBACK_TEST(TestTCPSocketPrivate, ReadWriteSSL, filter);
   RUN_CALLBACK_TEST(TestTCPSocketPrivate, ConnectAddress, filter);
   RUN_CALLBACK_TEST(TestTCPSocketPrivate, SetOption, filter);
+  RUN_CALLBACK_TEST(TestTCPSocketPrivate, LargeRead, filter);
 }
 
 std::string TestTCPSocketPrivate::TestBasic() {
   pp::TCPSocketPrivate socket(instance_);
   TestCompletionCallback cb(instance_->pp_instance(), callback_type());
 
   cb.WaitForResult(socket.Connect(host_.c_str(), port_, cb.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(cb);
   ASSERT_EQ(PP_OK, cb.result());
 
@@ skipping 109 matching lines @@
       socket.SetOption(PP_TCPSOCKETOPTION_PRIVATE_INVALID, true,
                        cb.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(cb);
   ASSERT_EQ(PP_ERROR_BADARGUMENT, cb.result());
 
   socket.Disconnect();
 
   PASS();
 }
 
+std::string TestTCPSocketPrivate::TestLargeRead() {
+  pp::TCPSocketPrivate socket(instance_);
+  {
+    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
+
+    cb.WaitForResult(socket.Connect(host_.c_str(), port_, cb.GetCallback()));
+    CHECK_CALLBACK_BEHAVIOR(cb);
+    ASSERT_EQ(PP_OK, cb.result());
+  }
+
+  ASSERT_EQ(PP_OK, WriteStringToSocket(&socket, "GET / HTTP/1.0\r\n\r\n"));
+
+  const size_t kReadSize = 1024 * 1024 + 32;
+  // Create large buffer in heap to prevent run-time errors related to
+  // limits on stack size.
+  char* buffer = new (std::nothrow) char[kReadSize];
+  ASSERT_TRUE(buffer != NULL);
+
+  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
+  cb.WaitForResult(socket.Read(buffer, kReadSize * sizeof(*buffer),
+                               cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_LE(0, cb.result());
+
+  delete [] buffer;
+
+  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(), callback_type());
     int32_t rv = socket->Read(buffer, sizeof(buffer), cb.GetCallback());
@@ skipping 28 matching lines @@
     if (cb.result() < 0)
       return cb.result();
     if (cb.result() == 0)
       return PP_ERROR_FAILED;
     written += cb.result();
   }
   if (written != s.size())
     return PP_ERROR_FAILED;
   return PP_OK;
 }