Read recv timestamps from socket (posix only).

webrtc/base/testclient.cc

 /*
  *  Copyright 2004 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.
  */
 
 #include "webrtc/base/testclient.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 
 namespace rtc {
 
 // DESIGN: Each packet received is put it into a list of packets.
 //         Callers can retrieve received packets from any thread by calling
 //         NextPacket.
 
 TestClient::TestClient(AsyncPacketSocket* socket)
-    : socket_(socket), ready_to_send_(false) {
+    : socket_(socket), ready_to_send_(false), prev_packet_timestamp_(-1) {
   packets_ = new std::vector<Packet*>();
   socket_->SignalReadPacket.connect(this, &TestClient::OnPacket);
   socket_->SignalReadyToSend.connect(this, &TestClient::OnReadyToSend);
 }
 
 TestClient::~TestClient() {
   delete socket_;
   for (unsigned i = 0; i < packets_->size(); i++)
     delete (*packets_)[i];
   delete packets_;
@@ skipping 50 matching lines @@
   }
 
   return packet;
 }
 
 bool TestClient::CheckNextPacket(const char* buf, size_t size,
                                  SocketAddress* addr) {
   bool res = false;
   Packet* packet = NextPacket(kTimeoutMs);
   if (packet) {
-    res = (packet->size == size && memcmp(packet->buf, buf, size) == 0);
+    int64_t packet_timestamp = packet->packet_time.timestamp;
+    res =
+        packet->size == size && memcmp(packet->buf, buf, size) == 0 &&
+        (prev_packet_timestamp_ == -1 ||

[juberti2, 2016/05/11 19:57:22]

I think that -1 should only be allowed when we know no timestamps are available.
For example, in the UdpInternal test, we should fail if we get -1 on a supported
platform.

We should also check this against our own Time() clock somehow - perhaps by
adding a new CheckNextPacketWithTime method that allows an external time to be
passed in (which would be used in the UdpInternal test).

[stefan-webrtc, 2016/05/12 11:19:53]

We don't expect -1 to be returned on any platform since we fall back to system
time if the socket doesn't provide us with a timestamp. I'll verify that though.
This should also be possible to check on all platforms since we have the
fallback. I'm now comparing deltas between two packets to avoid issues where the
socket timestamp has a different epoch than our own time implementation.

+         (packet_timestamp >= 0 && packet_timestamp >= prev_packet_timestamp_));
+    prev_packet_timestamp_ = packet_timestamp;
     if (addr)
       *addr = packet->addr;
     delete packet;
   }
   return res;
 }
 
 bool TestClient::CheckNoPacket() {
   bool res;
   Packet* packet = NextPacket(kNoPacketTimeoutMs);
@@ skipping 11 matching lines @@
 }
 
 bool TestClient::ready_to_send() const {
   return ready_to_send_;
 }
 
 void TestClient::OnPacket(AsyncPacketSocket* socket, const char* buf,
                           size_t size, const SocketAddress& remote_addr,
                           const PacketTime& packet_time) {
   CritScope cs(&crit_);
-  packets_->push_back(new Packet(remote_addr, buf, size));
+  packets_->push_back(new Packet(remote_addr, buf, size, packet_time));
 }
 
 void TestClient::OnReadyToSend(AsyncPacketSocket* socket) {
   ready_to_send_ = true;
 }
 
-TestClient::Packet::Packet(const SocketAddress& a, const char* b, size_t s)
-    : addr(a), buf(0), size(s) {
+TestClient::Packet::Packet(const SocketAddress& a,
+                           const char* b,
+                           size_t s,
+                           const PacketTime& packet_time)
+    : addr(a), buf(0), size(s), packet_time(packet_time) {
   buf = new char[size];
   memcpy(buf, b, size);
 }
 
 TestClient::Packet::Packet(const Packet& p)
-    : addr(p.addr), buf(0), size(p.size) {
+    : addr(p.addr), buf(0), size(p.size), packet_time(p.packet_time) {
   buf = new char[size];
   memcpy(buf, p.buf, size);
 }
 
 TestClient::Packet::~Packet() {
   delete[] buf;
 }
 
 }  // namespace rtc