Reland Enable socketservers unittests on windows.

webrtc/base/socket_unittest.cc

 /*
  *  Copyright 2007 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 663 matching lines @@
   TypedMessageData<AsyncSocket*> data(client.get());
   thread->Send(RTC_FROM_HERE, &sleeper, 0, &data);
   EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
 
   // But should signal when process_io is true.
   EXPECT_TRUE_WAIT((sink.Check(accepted.get(), testing::SSE_READ)), kTimeout);
   EXPECT_LT(0, accepted->Recv(buf, 1024, nullptr));
 }
 
 void SocketTest::TcpInternal(const IPAddress& loopback, size_t data_size,
-    ssize_t max_send_size) {
+    ptrdiff_t max_send_size) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create receiving client.
   std::unique_ptr<AsyncSocket> receiver(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(receiver.get());
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
@@ skipping 17 matching lines @@
   EXPECT_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress());
   EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress());
 
   // Create test data.
   rtc::Buffer send_buffer(0, data_size);
   rtc::Buffer recv_buffer(0, data_size);
   for (size_t i = 0; i < data_size; ++i) {
     char ch = static_cast<char>(i % 256);
     send_buffer.AppendData(&ch, sizeof(ch));
   }
+  rtc::Buffer recved_data(0, data_size);
 
   // Send and receive a bunch of data.
   size_t sent_size = 0;
   bool writable = true;
   bool send_called = false;
   bool readable = false;
   bool recv_called = false;
   while (recv_buffer.size() < send_buffer.size()) {
     // Send as much as we can while we're cleared to send.
     while (writable && sent_size < send_buffer.size()) {
       int unsent_size = static_cast<int>(send_buffer.size() - sent_size);
       int sent = sender->Send(send_buffer.data() + sent_size, unsent_size);
       if (!send_called) {
         // The first Send() after connecting or getting writability should
         // succeed and send some data.
         EXPECT_GT(sent, 0);
         send_called = true;
       }
       if (sent >= 0) {
         EXPECT_LE(sent, unsent_size);
         sent_size += sent;
         if (max_send_size >= 0) {
-          EXPECT_LE(static_cast<ssize_t>(sent), max_send_size);
+          EXPECT_LE(static_cast<ptrdiff_t>(sent), max_send_size);
           if (sent < unsent_size) {
             // If max_send_size is limiting the amount to send per call such
             // that the sent amount is less than the unsent amount, we simulate
             // that the socket is no longer writable.
             writable = false;
           }
         }
       } else {
         ASSERT_TRUE(sender->IsBlocking());
         writable = false;
       }
     }
 
     // Read all the sent data.
     while (recv_buffer.size() < sent_size) {
       if (!readable) {
         // Wait until data is available.
         EXPECT_TRUE_WAIT(sink.Check(receiver.get(), testing::SSE_READ),
             kTimeout);
         readable = true;
         recv_called = false;
       }
 
       // Receive as much as we can get in a single recv call.
-      char recved_data[data_size];
-      int recved_size = receiver->Recv(recved_data, data_size, nullptr);
+      int recved_size = receiver->Recv(recved_data.data(), data_size, nullptr);
 
       if (!recv_called) {
         // The first Recv() after getting readability should succeed and receive
         // some data.
         // TODO: The following line is disabled due to flakey pulse
         //     builds.  Re-enable if/when possible.
         // EXPECT_GT(recved_size, 0);
         recv_called = true;
       }
       if (recved_size >= 0) {
         EXPECT_LE(static_cast<size_t>(recved_size),
             sent_size - recv_buffer.size());
-        recv_buffer.AppendData(recved_data, recved_size);
+        recv_buffer.AppendData(recved_data.data(), recved_size);
       } else {
         ASSERT_TRUE(receiver->IsBlocking());
         readable = false;
       }
     }
 
     // Once all that we've sent has been received, expect to be able to send
     // again.
     if (!writable) {
-      EXPECT_TRUE_WAIT(sink.Check(sender.get(), testing::SSE_WRITE),
+      ASSERT_TRUE_WAIT(sink.Check(sender.get(), testing::SSE_WRITE),
                        kTimeout);
       writable = true;
       send_called = false;
     }
   }
 
   // The received data matches the sent data.
   EXPECT_EQ(data_size, sent_size);
   EXPECT_EQ(data_size, recv_buffer.size());
   EXPECT_EQ(recv_buffer, send_buffer);
@@ skipping 238 matching lines @@
 
   const int64_t kTimeBetweenPacketsMs = 10;
   Thread::SleepMs(kTimeBetweenPacketsMs);
 
   socket->SendTo("bar", 3, address);
   socket->RecvFrom(buffer, 3, nullptr, &timestamp);
   EXPECT_NEAR(timestamp, prev_timestamp + kTimeBetweenPacketsMs * 1000, 2000);
 }
 
 }  // namespace rtc