Change default timestamp to 64 bits in all webrtc directories.

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 17 matching lines @@
 using namespace rtc;
 
 // Sends at a constant rate but with random packet sizes.
 struct Sender : public MessageHandler {
   Sender(Thread* th, AsyncSocket* s, uint32_t rt)
       : thread(th),
         socket(new AsyncUDPSocket(s)),
         done(false),
         rate(rt),
         count(0) {
-    last_send = rtc::Time();
+    last_send = rtc::TimeMillis();
     thread->PostDelayed(NextDelay(), this, 1);
   }
 
   uint32_t NextDelay() {
     uint32_t size = (rand() % 4096) + 1;
     return 1000 * size / rate;
   }
 
   void OnMessage(Message* pmsg) {
     ASSERT_EQ(1u, pmsg->message_id);
 
     if (done)
       return;
 
-    uint32_t cur_time = rtc::Time();
-    uint32_t delay = cur_time - last_send;
-    uint32_t size = rate * delay / 1000;
+    int64_t cur_time = rtc::TimeMillis();
+    int64_t delay = cur_time - last_send;
+    uint32_t size = static_cast<uint32_t>(rate * delay / 1000);
     size = std::min<uint32_t>(size, 4096);
     size = std::max<uint32_t>(size, sizeof(uint32_t));
 
     count += size;
     memcpy(dummy, &cur_time, sizeof(cur_time));
     socket->Send(dummy, size, options);
 
     last_send = cur_time;
     thread->PostDelayed(NextDelay(), this, 1);
   }
 
   Thread* thread;
   std::unique_ptr<AsyncUDPSocket> socket;
   rtc::PacketOptions options;
   bool done;
   uint32_t rate;  // bytes per second
   uint32_t count;
-  uint32_t last_send;
+  int64_t last_send;
   char dummy[4096];
 };
 
 struct Receiver : public MessageHandler, public sigslot::has_slots<> {
   Receiver(Thread* th, AsyncSocket* s, uint32_t bw)
       : thread(th),
         socket(new AsyncUDPSocket(s)),
         bandwidth(bw),
         done(false),
         count(0),
@@ skipping 12 matching lines @@
   void OnReadPacket(AsyncPacketSocket* s, const char* data, size_t size,
                     const SocketAddress& remote_addr,
                     const PacketTime& packet_time) {
     ASSERT_EQ(socket.get(), s);
     ASSERT_GE(size, 4U);
 
     count += size;
     sec_count += size;
 
     uint32_t send_time = *reinterpret_cast<const uint32_t*>(data);
-    uint32_t recv_time = rtc::Time();
+    uint32_t recv_time = rtc::TimeMillis();
     uint32_t delay = recv_time - send_time;
     sum += delay;
     sum_sq += delay * delay;
     samples += 1;
   }
 
   void OnMessage(Message* pmsg) {
     ASSERT_EQ(1u, pmsg->message_id);
 
     if (done)
@@ skipping 935 matching lines @@
           << " N=" << kTestSamples[sidx];
         EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         delete f;
       }
     }
   }
 }