Change default timestamp to 64 bits in all webrtc directories.

webrtc/media/base/rtpdump.cc

 /*
  *  Copyright (c) 2010 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 10 matching lines @@
 
 namespace {
 static const int kRtpSsrcOffset = 8;
 const int  kWarnSlowWritesDelayMs = 50;
 }  // namespace
 
 namespace cricket {
 
 const char RtpDumpFileHeader::kFirstLine[] = "#!rtpplay1.0 0.0.0.0/0\n";
 
-RtpDumpFileHeader::RtpDumpFileHeader(uint32_t start_ms, uint32_t s, uint16_t p)
-    : start_sec(start_ms / 1000),
-      start_usec(start_ms % 1000 * 1000),
+RtpDumpFileHeader::RtpDumpFileHeader(int64_t start_ms, uint32_t s, uint16_t p)
+    : start_sec(static_cast<uint32_t>(start_ms / 1000)),

[Taylor Brandstetter, 2016/04/05 01:08:15]

Why a uint32_t?

[pthatcher1, 2016/04/11 20:56:59]

I agree.  Why not just change to uint64_t everywhere here?

[honghaiz3, 2016/04/18 23:39:04]

RtpDumpFileHeader defines the format of the RtpDumpFile header and the output
may be used elsewhere. If we change the structure here, it may cause issue when
other apps (like wireshark) try to read the dumped file. 
So I think we should avoid changing it. 

+      start_usec(static_cast<uint32_t>(start_ms % 1000 * 1000)),
       source(s),
       port(p),
-      padding(0) {
-}
+      padding(0) {}
 
 void RtpDumpFileHeader::WriteToByteBuffer(rtc::ByteBufferWriter* buf) {
   buf->WriteUInt32(start_sec);
   buf->WriteUInt32(start_usec);
   buf->WriteUInt32(source);
   buf->WriteUInt16(port);
   buf->WriteUInt16(padding);
 }
 
-static const uint32_t kDefaultTimeIncrease = 30;
+static const int kDefaultTimeIncrease = 30;
 
 bool RtpDumpPacket::IsValidRtpPacket() const {
   return original_data_len >= data.size() &&
       data.size() >= kMinRtpPacketLen;
 }
 
 bool RtpDumpPacket::IsValidRtcpPacket() const {
   return original_data_len == 0 &&
       data.size() >= kMinRtcpPacketLen;
 }
@@ skipping 250 matching lines @@
       start_time_ms_(rtc::Time()),
       warn_slow_writes_delay_(kWarnSlowWritesDelayMs) {
 }
 
 void RtpDumpWriter::set_packet_filter(int filter) {
   packet_filter_ = filter;
   LOG(LS_INFO) << "RtpDumpWriter set_packet_filter to " << packet_filter_;
 }
 
 uint32_t RtpDumpWriter::GetElapsedTime() const {
-  return rtc::TimeSince(start_time_ms_);
+  return static_cast<uint32_t>(rtc::Time() - start_time_ms_);
 }
 
 rtc::StreamResult RtpDumpWriter::WriteFileHeader() {
   rtc::StreamResult res = WriteToStream(
       RtpDumpFileHeader::kFirstLine,
       strlen(RtpDumpFileHeader::kFirstLine));
   if (res != rtc::SR_SUCCESS) {
     return res;
   }
 
@@ skipping 59 matching lines @@
       // RTCP header + payload
       filtered_len = data_len;
     }
   }
 
   return filtered_len;
 }
 
 rtc::StreamResult RtpDumpWriter::WriteToStream(
     const void* data, size_t data_len) {
-  uint32_t before = rtc::Time();
+  int64_t before = rtc::Time();
   rtc::StreamResult result =
       stream_->WriteAll(data, data_len, NULL, NULL);
-  uint32_t delay = rtc::TimeSince(before);
+  uint32_t delay = static_cast<uint32_t>(rtc::TimeSince(before));
   if (delay >= warn_slow_writes_delay_) {
     LOG(LS_WARNING) << "Slow RtpDump: took " << delay << "ms to write "
                     << data_len << " bytes.";
   }
   return result;
 }
 
 }  // namespace cricket