Read recv timestamps from socket (posix only).

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 138 matching lines @@
 
 void SocketTest::TestSingleFlowControlCallbackIPv6() {
   MAYBE_SKIP_IPV6;
   SingleFlowControlCallbackInternal(kIPv6Loopback);
 }
 
 void SocketTest::TestUdpIPv4() {
   UdpInternal(kIPv4Loopback);
 }
 
+void SocketTest::TestUdpIpv4Interval() {
+  SendUdpInterval(kIPv4Loopback, 5000);
+}
+
 void SocketTest::TestUdpIPv6() {
   MAYBE_SKIP_IPV6;
   UdpInternal(kIPv6Loopback);
 }
 
+void SocketTest::TestUdpIpv6Interval() {
+  MAYBE_SKIP_IPV6;
+  SendUdpInterval(kIPv6Loopback, 5000);
+}
+
 void SocketTest::TestUdpReadyToSendIPv4() {
 #if !defined(WEBRTC_MAC)
   // TODO(ronghuawu): Enable this test on mac/ios.
   UdpReadyToSend(kIPv4Loopback);
 #endif
 }
 
 void SocketTest::TestUdpReadyToSendIPv6() {
 #if defined(WEBRTC_WIN)
   // TODO(ronghuawu): Enable this test (currently flakey) on mac and linux.
@@ skipping 361 matching lines @@
   accepted->Close();
   EXPECT_EQ(AsyncSocket::CS_CLOSED, accepted->GetState());
 
   // Expect that the client is notified, and has not yet closed.
   EXPECT_TRUE_WAIT(sink.Check(client.get(), testing::SSE_READ), kTimeout);
   EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState());
 
   // Ensure the data can be read.
   char buffer[10];
-  EXPECT_EQ(1, client->Recv(buffer, sizeof(buffer)));
+  EXPECT_EQ(1, client->Recv(buffer, sizeof(buffer), nullptr));
   EXPECT_EQ('a', buffer[0]);
 
   // Now we should close, but the remote address will remain.
   EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
   EXPECT_TRUE(sink.Check(client.get(), testing::SSE_CLOSE));
   EXPECT_FALSE(client->GetRemoteAddress().IsAnyIP());
 
   // The closer should not get a close signal.
   EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_CLOSE));
   EXPECT_TRUE(accepted->GetRemoteAddress().IsNil());
@@ skipping 111 matching lines @@
   // Shouldn't signal when blocked in a thread Send, where process_io is false.
   std::unique_ptr<Thread> thread(new Thread());
   thread->Start();
   Sleeper sleeper;
   TypedMessageData<AsyncSocket*> data(client.get());
   thread->Send(&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));
+  EXPECT_LT(0, accepted->Recv(buf, 1024, nullptr));
 }
 
 void SocketTest::TcpInternal(const IPAddress& loopback, size_t data_size,
     ssize_t max_send_size) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create receiving client.
   std::unique_ptr<AsyncSocket> receiver(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
@@ skipping 69 matching lines @@
       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);
+      int recved_size = receiver->Recv(recved_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) {
@@ skipping 66 matching lines @@
   char buf[1024 * 16] = {0};
   int sends = 0;
   while (++sends && accepted->Send(&buf, arraysize(buf)) != -1) {}
   EXPECT_TRUE(accepted->IsBlocking());
 
   // Wait until data is available.
   EXPECT_TRUE_WAIT(sink.Check(client.get(), testing::SSE_READ), kTimeout);
 
   // Pull data.
   for (int i = 0; i < sends; ++i) {
-    client->Recv(buf, arraysize(buf));
+    client->Recv(buf, arraysize(buf), nullptr);
   }
 
   // Expect at least one additional writable callback.
   EXPECT_TRUE_WAIT(sink.Check(accepted.get(), testing::SSE_WRITE), kTimeout);
 
   // Adding data in response to the writeable callback shouldn't cause infinite
   // callbacks.
   int extras = 0;
   for (int i = 0; i < 100; ++i) {
     accepted->Send(&buf, arraysize(buf));
@@ skipping 48 matching lines @@
 
     SocketAddress addr5;
     EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr4));
     EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr5));
     EXPECT_EQ(addr5, addr1);
 
     addr2 = addr4;
   }
 }
 
+void SocketTest::SendUdpInterval(const IPAddress& loopback,
+                                 int64_t time_interval_ms) {
+  SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
+  AsyncSocket* socket = ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM);
+  EXPECT_EQ(AsyncSocket::CS_CLOSED, socket->GetState());
+  EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
+  SocketAddress address = socket->GetLocalAddress();
+  delete socket;
+
+  // Test send/receive behavior.
+  std::unique_ptr<TestClient> client1(
+      new TestClient(AsyncUDPSocket::Create(ss_, address)));
+
+  int64_t start_ms = rtc::TimeMillis();
+  while (rtc::TimeMillis() - start_ms < time_interval_ms) {
+    EXPECT_EQ(3, client1->SendTo("foo", 3, address));
+    EXPECT_TRUE(client1->CheckNextPacket("foo", 3, nullptr));
+  }
+}
+
 void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
   SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
   // RFC 5737 - The blocks 192.0.2.0/24 (TEST-NET-1) ... are provided for use in
   // documentation.
   // RFC 3849 - 2001:DB8::/32 as a documentation-only prefix.
   std::string dest = (loopback.family() == AF_INET6) ?
       "2001:db8::1" : "192.0.2.0";
   SocketAddress test_addr(dest, 2345);
 
   // Test send
@@ skipping 85 matching lines @@
     ASSERT_EQ(-1, mtu_socket->EstimateMTU(&mtu));
 #else
     // and the behavior seems unpredictable on Linux,
     // failing on the build machine
     // but succeeding on my Ubiquity instance.
 #endif
   }
 }
 
 }  // namespace rtc