Read recv timestamps from socket (posix only).

webrtc/base/natsocketfactory.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.
  */
 
@@ skipping 137 matching lines @@
     size_t encoded_size = size + addrlength;
     memcpy(buf.get() + addrlength, data, size);
     int result = socket_->SendTo(buf.get(), encoded_size, server_addr_);
     if (result >= 0) {
       ASSERT(result == static_cast<int>(encoded_size));
       result = result - static_cast<int>(addrlength);
     }
     return result;
   }
 
-  int Recv(void* data, size_t size) override {
+  int Recv(void* data, size_t size, int64_t* timestamp) override {
     SocketAddress addr;
-    return RecvFrom(data, size, &addr);
+    return RecvFrom(data, size, &addr, timestamp);
   }
 
-  int RecvFrom(void* data, size_t size, SocketAddress* out_addr) override {
+  int RecvFrom(void* data,
+               size_t size,
+               SocketAddress* out_addr,
+               int64_t* timestamp) override {
     if (server_addr_.IsNil() || type_ == SOCK_STREAM) {
-      return socket_->RecvFrom(data, size, out_addr);
+      return socket_->RecvFrom(data, size, out_addr, timestamp);
     }
     // Make sure we have enough room to read the requested amount plus the
     // largest possible header address.
     SocketAddress remote_addr;
     Grow(size + kNATEncodedIPv6AddressSize);
 
     // Read the packet from the socket.
-    int result = socket_->RecvFrom(buf_, size_, &remote_addr);
+    int result = socket_->RecvFrom(buf_, size_, &remote_addr, timestamp);
     if (result >= 0) {
       ASSERT(remote_addr == server_addr_);
 
       // TODO: we need better framing so we know how many bytes we can
       // return before we need to read the next address. For UDP, this will be
       // fine as long as the reader always reads everything in the packet.
       ASSERT((size_t)result < size_);
 
       // Decode the wire packet into the actual results.
       SocketAddress real_remote_addr;
@@ skipping 87 matching lines @@
   // Sends the destination address to the server to tell it to connect.
   void SendConnectRequest() {
     char buf[kNATEncodedIPv6AddressSize];
     size_t length = PackAddressForNAT(buf, arraysize(buf), remote_addr_);
     socket_->Send(buf, length);
   }
 
   // Handles the byte sent back from the server and fires the appropriate event.
   void HandleConnectReply() {
     char code;
-    socket_->Recv(&code, sizeof(code));
+    socket_->Recv(&code, sizeof(code), nullptr);
     if (code == 0) {
       connected_ = true;
       SignalConnectEvent(this);
     } else {
       Close();
       SignalCloseEvent(this, code);
     }
   }
 
   NATInternalSocketFactory* sf_;
@@ skipping 202 matching lines @@
 NATSocketServer::Translator* NATSocketServer::TranslatorMap::FindClient(
     const SocketAddress& int_ip) {
   Translator* nat = NULL;
   for (TranslatorMap::iterator it = begin(); it != end() && !nat; ++it) {
     nat = it->second->FindClient(int_ip);
   }
   return nat;
 }
 
 }  // namespace rtc