Delete Timing class, timing.h, and update all users.

webrtc/media/base/rtpdataengine.cc

 /*
  *  Copyright (c) 2012 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/media/base/rtpdataengine.h"
 
 #include "webrtc/base/copyonwritebuffer.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/ratelimiter.h"
-#include "webrtc/base/timing.h"
 #include "webrtc/media/base/codec.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/rtputils.h"
 #include "webrtc/media/base/streamparams.h"
 
 namespace cricket {
 
 // We want to avoid IP fragmentation.
 static const size_t kDataMaxRtpPacketLen = 1200U;
 // We reserve space after the RTP header for future wiggle room.
 static const unsigned char kReservedSpace[] = {
   0x00, 0x00, 0x00, 0x00
 };
 
 // Amount of overhead SRTP may take.  We need to leave room in the
 // buffer for it, otherwise SRTP will fail later.  If SRTP ever uses
 // more than this, we need to increase this number.
 static const size_t kMaxSrtpHmacOverhead = 16;
 
 RtpDataEngine::RtpDataEngine() {
   data_codecs_.push_back(
       DataCodec(kGoogleRtpDataCodecId, kGoogleRtpDataCodecName));
-  SetTiming(new rtc::Timing());
 }
 
 DataMediaChannel* RtpDataEngine::CreateChannel(
     DataChannelType data_channel_type) {
   if (data_channel_type != DCT_RTP) {
     return NULL;
   }
-  return new RtpDataMediaChannel(timing_.get());
+  return new RtpDataMediaChannel();
 }
 
 bool FindCodecByName(const std::vector<DataCodec>& codecs,
                      const std::string& name, DataCodec* codec_out) {
   std::vector<DataCodec>::const_iterator iter;
   for (iter = codecs.begin(); iter != codecs.end(); ++iter) {
     if (iter->name == name) {
       *codec_out = *iter;
       return true;
     }
   }
   return false;
 }
 
-RtpDataMediaChannel::RtpDataMediaChannel(rtc::Timing* timing) {
-  Construct(timing);
+RtpDataMediaChannel::RtpDataMediaChannel() {
+  Construct();
 }
 
-RtpDataMediaChannel::RtpDataMediaChannel() {
-  Construct(NULL);
-}
-
-void RtpDataMediaChannel::Construct(rtc::Timing* timing) {
+void RtpDataMediaChannel::Construct() {
   sending_ = false;
   receiving_ = false;
-  timing_ = timing;
   send_limiter_.reset(new rtc::RateLimiter(kDataMaxBandwidth / 8, 1.0));
 }
 
 
 RtpDataMediaChannel::~RtpDataMediaChannel() {
   std::map<uint32_t, RtpClock*>::const_iterator iter;
   for (iter = rtp_clock_by_send_ssrc_.begin();
        iter != rtp_clock_by_send_ssrc_.end();
        ++iter) {
     delete iter->second;
@@ skipping 221 matching lines @@
                     << kGoogleRtpDataCodecName;
     return false;
   }
 
   size_t packet_len = (kMinRtpPacketLen + sizeof(kReservedSpace) +
                        payload.size() + kMaxSrtpHmacOverhead);
   if (packet_len > kDataMaxRtpPacketLen) {
     return false;
   }
 
-  double now = timing_->TimerNow();
+  double now =
+      rtc::TimeMicros() / static_cast<double>(rtc::kNumMicrosecsPerSec);
 
   if (!send_limiter_->CanUse(packet_len, now)) {
     LOG(LS_VERBOSE) << "Dropped data packet of len=" << packet_len
                     << "; already sent " << send_limiter_->used_in_period()
                     << "/" << send_limiter_->max_per_period();
     return false;
   }
 
   RtpHeader header;
   header.payload_type = found_codec.id;
@@ skipping 16 matching lines @@
 
   MediaChannel::SendPacket(&packet, rtc::PacketOptions());
   send_limiter_->Use(packet_len, now);
   if (result) {
     *result = SDR_SUCCESS;
   }
   return true;
 }
 
 }  // namespace cricket