Read recv timestamps from socket (posix only).

webrtc/base/socketadapters.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 18 matching lines @@
 #include "webrtc/base/bytebuffer.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/httpcommon.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/socketadapters.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 
 #if defined(WEBRTC_WIN)
 #include "webrtc/base/sec_buffer.h"
-#endif  // WEBRTC_WIN 
+#endif  // WEBRTC_WIN
 
 namespace rtc {
 
 BufferedReadAdapter::BufferedReadAdapter(AsyncSocket* socket, size_t size)
     : AsyncSocketAdapter(socket), buffer_size_(size),
       data_len_(0), buffering_(false) {
   buffer_ = new char[buffer_size_];
 }
 
 BufferedReadAdapter::~BufferedReadAdapter() {
   delete [] buffer_;
 }
 
 int BufferedReadAdapter::Send(const void *pv, size_t cb) {
   if (buffering_) {
     // TODO: Spoof error better; Signal Writeable
     socket_->SetError(EWOULDBLOCK);
     return -1;
   }
   return AsyncSocketAdapter::Send(pv, cb);
 }
 
-int BufferedReadAdapter::Recv(void *pv, size_t cb) {
+int BufferedReadAdapter::Recv(void* pv, size_t cb, int64_t* timestamp) {
   if (buffering_) {
     socket_->SetError(EWOULDBLOCK);
     return -1;
   }
 
   size_t read = 0;
 
   if (data_len_) {
     read = std::min(cb, data_len_);
     memcpy(pv, buffer_, read);
     data_len_ -= read;
     if (data_len_ > 0) {
       memmove(buffer_, buffer_ + read, data_len_);
     }
     pv = static_cast<char *>(pv) + read;
     cb -= read;
   }
 
   // FIX: If cb == 0, we won't generate another read event
 
-  int res = AsyncSocketAdapter::Recv(pv, cb);
+  int res = AsyncSocketAdapter::Recv(pv, cb, timestamp);
   if (res >= 0) {
     // Read from socket and possibly buffer; return combined length
     return res + static_cast<int>(read);
   }
 
   if (read > 0) {
     // Failed to read from socket, but still read something from buffer
     return static_cast<int>(read);
   }
 
@@ skipping 12 matching lines @@
     AsyncSocketAdapter::OnReadEvent(socket);
     return;
   }
 
   if (data_len_ >= buffer_size_) {
     LOG(INFO) << "Input buffer overflow";
     ASSERT(false);
     data_len_ = 0;
   }
 
-  int len = socket_->Recv(buffer_ + data_len_, buffer_size_ - data_len_);
+  int64_t timestamp;
+  int len =
+      socket_->Recv(buffer_ + data_len_, buffer_size_ - data_len_, &timestamp);
   if (len < 0) {
     // TODO: Do something better like forwarding the error to the user.
     LOG_ERR(INFO) << "Recv";
     return;
   }
 
   data_len_ += len;
 
   ProcessInput(buffer_, &data_len_);
 }
@@ skipping 740 matching lines @@
 }
 
 int LoggingSocketAdapter::SendTo(const void *pv, size_t cb,
                              const SocketAddress& addr) {
   int res = AsyncSocketAdapter::SendTo(pv, cb, addr);
   if (res > 0)
     LogMultiline(level_, label_.c_str(), false, pv, res, hex_mode_, &lms_);
   return res;
 }
 
-int LoggingSocketAdapter::Recv(void *pv, size_t cb) {
-  int res = AsyncSocketAdapter::Recv(pv, cb);
+int LoggingSocketAdapter::Recv(void* pv, size_t cb, int64_t* timestamp) {
+  int res = AsyncSocketAdapter::Recv(pv, cb, timestamp);
   if (res > 0)
     LogMultiline(level_, label_.c_str(), true, pv, res, hex_mode_, &lms_);
   return res;
 }
 
-int LoggingSocketAdapter::RecvFrom(void *pv, size_t cb, SocketAddress *paddr) {
-  int res = AsyncSocketAdapter::RecvFrom(pv, cb, paddr);
+int LoggingSocketAdapter::RecvFrom(void* pv,
+                                   size_t cb,
+                                   SocketAddress* paddr,
+                                   int64_t* timestamp) {
+  int res = AsyncSocketAdapter::RecvFrom(pv, cb, paddr, timestamp);
   if (res > 0)
     LogMultiline(level_, label_.c_str(), true, pv, res, hex_mode_, &lms_);
   return res;
 }
 
 int LoggingSocketAdapter::Close() {
   LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_);
   LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_);
   LOG_V(level_) << label_ << " Closed locally";
   return socket_->Close();
 }
 
 void LoggingSocketAdapter::OnConnectEvent(AsyncSocket * socket) {
   LOG_V(level_) << label_ << " Connected";
   AsyncSocketAdapter::OnConnectEvent(socket);
 }
 
 void LoggingSocketAdapter::OnCloseEvent(AsyncSocket * socket, int err) {
   LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_);
   LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_);
   LOG_V(level_) << label_ << " Closed with error: " << err;
   AsyncSocketAdapter::OnCloseEvent(socket, err);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc