Read recv timestamps from socket (posix only).

webrtc/base/virtualsocket_unittest.cc

 /*
  *  Copyright 2006 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 446 matching lines @@
     EXPECT_EQ(b->GetRemoteAddress(), a->GetLocalAddress());
 
     EXPECT_EQ(1, a->Send("a", 1));
     b->Close();
     EXPECT_EQ(1, a->Send("b", 1));
 
     ss_->ProcessMessagesUntilIdle();
 
     char buffer[10];
     EXPECT_FALSE(sink.Check(b.get(), testing::SSE_READ));
-    EXPECT_EQ(-1, b->Recv(buffer, 10));
+    int64_t timestamp;
+    EXPECT_EQ(-1, b->Recv(buffer, 10, &timestamp));
 
     EXPECT_TRUE(sink.Check(a, testing::SSE_CLOSE));
     EXPECT_EQ(a->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr);
 
     // No signal for Closer
     EXPECT_FALSE(sink.Check(b.get(), testing::SSE_CLOSE));
     EXPECT_EQ(b->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
   }
@@ skipping 46 matching lines @@
     ss_->ProcessMessagesUntilIdle();
     EXPECT_FALSE(sink.Check(a, testing::SSE_WRITE));
     EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
 
     // No more room in send or receive buffer
     result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
     EXPECT_EQ(-1, result);
     EXPECT_TRUE(a->IsBlocking());
 
     // Read a subset of the data
-    result = b->Recv(recv_buffer + recv_pos, 500);
+    int64_t timestamp;
+    result = b->Recv(recv_buffer + recv_pos, 500, &timestamp);
     EXPECT_EQ(500, result);
     recv_pos += result;
 
     ss_->ProcessMessagesUntilIdle();
     EXPECT_TRUE(sink.Check(a, testing::SSE_WRITE));
     EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
 
     // Room for more on the sending side
     result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
     EXPECT_EQ(500, result);
     send_pos += result;
 
     // Empty the recv buffer
     while (true) {
-      result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
+      result =
+          b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, &timestamp);
       if (result < 0) {
         EXPECT_EQ(-1, result);
         EXPECT_TRUE(b->IsBlocking());
         break;
       }
       recv_pos += result;
     }
 
     ss_->ProcessMessagesUntilIdle();
     EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
 
     // Continue to empty the recv buffer
     while (true) {
-      result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
+      result =
+          b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, &timestamp);
       if (result < 0) {
         EXPECT_EQ(-1, result);
         EXPECT_TRUE(b->IsBlocking());
         break;
       }
       recv_pos += result;
     }
 
     // Send last of the data
     result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
     EXPECT_EQ(500, result);
     send_pos += result;
 
     ss_->ProcessMessagesUntilIdle();
     EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
 
     // Receive the last of the data
     while (true) {
-      result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
+      result =
+          b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, &timestamp);
       if (result < 0) {
         EXPECT_EQ(-1, result);
         EXPECT_TRUE(b->IsBlocking());
         break;
       }
       recv_pos += result;
     }
 
     ss_->ProcessMessagesUntilIdle();
     EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
@@ skipping 26 matching lines @@
     char buffer[2] = { 0, 0 };
     const char cNumPackets = 10;
     for (char i = 0; i < cNumPackets; ++i) {
       buffer[0] = '0' + i;
       EXPECT_EQ(1, a->Send(buffer, 1));
     }
 
     ss_->ProcessMessagesUntilIdle();
 
     for (char i = 0; i < cNumPackets; ++i) {
-      EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer)));
+      int64_t timestamp;
+      EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer), &timestamp));
       EXPECT_EQ(static_cast<char>('0' + i), buffer[0]);
     }
 
     // Next, deliver packets at random intervals
     const uint32_t mean = 50;
     const uint32_t stddev = 50;
 
     ss_->set_delay_mean(mean);
     ss_->set_delay_stddev(stddev);
     ss_->UpdateDelayDistribution();
 
     for (char i = 0; i < cNumPackets; ++i) {
       buffer[0] = 'A' + i;
       EXPECT_EQ(1, a->Send(buffer, 1));
     }
 
     ss_->ProcessMessagesUntilIdle();
 
     for (char i = 0; i < cNumPackets; ++i) {
-      EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer)));
+      int64_t timestamp;
+      EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer), &timestamp));
       EXPECT_EQ(static_cast<char>('A' + i), buffer[0]);
     }
   }
 
   // It is important that initial_addr's port has to be 0 such that the
   // incremental port behavior could ensure the 2 Binds result in different
   // address.
   void BandwidthTest(const SocketAddress& initial_addr) {
     AsyncSocket* send_socket =
         ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
@@ skipping 392 matching lines @@
           << " N=" << kTestSamples[sidx];
         EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         delete f;
       }
     }
   }
 }