Re-implement dependency injection of TickTime into VCM and tests

This change basicly re-enables the change of r1220, which was
reverted in r1235 due to Clang issues.

The difference from r1220 is that the TickTimeInterface was
renamed to TickTimeClass, and no longer inherits from TickTime.

Review URL: http://webrtc-codereview.appspot.com/335006

git-svn-id: http://webrtc.googlecode.com/svn/trunk@1267 4adac7df-926f-26a2-2b94-8c16560cd09d

src/modules/video_coding/main/interface/video_coding.h

@@ -18,6 +18,7 @@
 namespace webrtc
 {
 
+class TickTimeBase;
 class VideoEncoder;
 class VideoDecoder;
 struct CodecSpecificInfo;
@@ -27,6 +28,9 @@ class VideoCodingModule : public Module
 public:
     static VideoCodingModule* Create(const WebRtc_Word32 id);
 
+    static VideoCodingModule* Create(const WebRtc_Word32 id,
+                                     TickTimeBase* clock);
+
     static void Destroy(VideoCodingModule* module);
 
     // Get number of supported codecs

src/modules/video_coding/main/source/content_metrics_processing.cc

@@ -9,7 +9,6 @@
  */
 
 #include "content_metrics_processing.h"
-#include "tick_time.h"
 #include "module_common_types.h"
 #include "video_coding_defines.h"
 

src/modules/video_coding/main/source/generic_decoder.cc

@@ -12,13 +12,15 @@
 #include "trace.h"
 #include "generic_decoder.h"
 #include "internal_defines.h"
-#include "tick_time.h"
+#include "tick_time_base.h"
 
 namespace webrtc {
 
-VCMDecodedFrameCallback::VCMDecodedFrameCallback(VCMTiming& timing)
+VCMDecodedFrameCallback::VCMDecodedFrameCallback(VCMTiming& timing,
+                                                 TickTimeBase* clock)
 :
 _critSect(CriticalSectionWrapper::CreateCriticalSection()),
+_clock(clock),
 _receiveCallback(NULL),
 _timing(timing),
 _timestampMap(kDecoderFrameMemoryLength)
@@ -53,7 +55,7 @@ WebRtc_Word32 VCMDecodedFrameCallback::Decoded(RawImage& decodedImage)
     _timing.StopDecodeTimer(
         decodedImage._timeStamp,
         frameInfo->decodeStartTimeMs,
-        VCMTickTime::MillisecondTimestamp());
+        _clock->MillisecondTimestamp());
 
     if (_receiveCallback != NULL)
     {
@@ -146,7 +148,8 @@ WebRtc_Word32 VCMGenericDecoder::InitDecode(const VideoCodec* settings,
     return _decoder.InitDecode(settings, numberOfCores);
 }
 
-WebRtc_Word32 VCMGenericDecoder::Decode(const VCMEncodedFrame& frame)
+WebRtc_Word32 VCMGenericDecoder::Decode(const VCMEncodedFrame& frame,
+                                        int64_t nowMs)
 {
     if (_requireKeyFrame &&
         !_keyFrameDecoded &&
@@ -157,7 +160,7 @@ WebRtc_Word32 VCMGenericDecoder::Decode(const VCMEncodedFrame& frame)
         // before we can decode delta frames.
         return VCM_CODEC_ERROR;
     }
-    _frameInfos[_nextFrameInfoIdx].decodeStartTimeMs = VCMTickTime::MillisecondTimestamp();
+    _frameInfos[_nextFrameInfoIdx].decodeStartTimeMs = nowMs;
     _frameInfos[_nextFrameInfoIdx].renderTimeMs = frame.RenderTimeMs();
     _callback->Map(frame.TimeStamp(), &_frameInfos[_nextFrameInfoIdx]);
 

src/modules/video_coding/main/source/generic_decoder.h

@@ -34,7 +34,7 @@ struct VCMFrameInformation
 class VCMDecodedFrameCallback : public DecodedImageCallback
 {
 public:
-    VCMDecodedFrameCallback(VCMTiming& timing);
+    VCMDecodedFrameCallback(VCMTiming& timing, TickTimeBase* clock);
     virtual ~VCMDecodedFrameCallback();
     void SetUserReceiveCallback(VCMReceiveCallback* receiveCallback);
 
@@ -49,6 +49,7 @@ public:
 
 private:
     CriticalSectionWrapper* _critSect;
+    TickTimeBase* _clock;
     VideoFrame _frame;
     VCMReceiveCallback* _receiveCallback;
     VCMTiming& _timing;
@@ -76,7 +77,7 @@ public:
     *
     *	inputVideoBuffer	reference to encoded video frame
     */
-    WebRtc_Word32 Decode(const VCMEncodedFrame& inputFrame);
+    WebRtc_Word32 Decode(const VCMEncodedFrame& inputFrame, int64_t nowMs);
 
     /**
     *	Free the decoder memory

src/modules/video_coding/main/source/inter_frame_delay.cc

@@ -9,20 +9,19 @@
  */
 
 #include "inter_frame_delay.h"
-#include "tick_time.h"
 
 namespace webrtc {
 
-VCMInterFrameDelay::VCMInterFrameDelay()
+VCMInterFrameDelay::VCMInterFrameDelay(int64_t currentWallClock)
 {
-    Reset();
+    Reset(currentWallClock);
 }
 
 // Resets the delay estimate
 void
-VCMInterFrameDelay::Reset()
+VCMInterFrameDelay::Reset(int64_t currentWallClock)
 {
-    _zeroWallClock = VCMTickTime::MillisecondTimestamp();
+    _zeroWallClock = currentWallClock;
     _wrapArounds = 0;
     _prevWallClock = 0;
     _prevTimestamp = 0;
@@ -34,13 +33,8 @@ VCMInterFrameDelay::Reset()
 bool
 VCMInterFrameDelay::CalculateDelay(WebRtc_UWord32 timestamp,
                                 WebRtc_Word64 *delay,
-                                WebRtc_Word64 currentWallClock /* = -1 */)
+                                int64_t currentWallClock)
 {
-    if (currentWallClock <= -1)
-    {
-        currentWallClock = VCMTickTime::MillisecondTimestamp();
-    }
-
     if (_prevWallClock == 0)
     {
         // First set of data, initialization, wait for next frame

src/modules/video_coding/main/source/inter_frame_delay.h

@@ -19,10 +19,10 @@ namespace webrtc
 class VCMInterFrameDelay
 {
 public:
-    VCMInterFrameDelay();
+    VCMInterFrameDelay(int64_t currentWallClock);
 
     // Resets the estimate. Zeros are given as parameters.
-    void Reset();
+    void Reset(int64_t currentWallClock);
 
     // Calculates the delay of a frame with the given timestamp.
     // This method is called when the frame is complete.
@@ -35,7 +35,7 @@ public:
     // Return value                 : true if OK, false when reordered timestamps
     bool CalculateDelay(WebRtc_UWord32 timestamp,
                         WebRtc_Word64 *delay,
-                        WebRtc_Word64 currentWallClock = -1);
+                        int64_t currentWallClock);
 
     // Returns the current difference between incoming timestamps
     //

src/modules/video_coding/main/source/jitter_buffer.cc

@@ -20,7 +20,7 @@
 
 #include "event.h"
 #include "trace.h"
-#include "tick_time.h"
+#include "modules/video_coding/main/source/tick_time_base.h"
 #include "list_wrapper.h"
 
 #include <cassert>
@@ -57,10 +57,13 @@ VCMJitterBuffer::CompleteDecodableKeyFrameCriteria(VCMFrameBuffer* frame,
 }
 
 // Constructor
-VCMJitterBuffer::VCMJitterBuffer(WebRtc_Word32 vcmId, WebRtc_Word32 receiverId,
+VCMJitterBuffer::VCMJitterBuffer(TickTimeBase* clock,
+                                 WebRtc_Word32 vcmId,
+                                 WebRtc_Word32 receiverId,
                                  bool master) :
     _vcmId(vcmId),
     _receiverId(receiverId),
+    _clock(clock),
     _running(false),
     _critSect(CriticalSectionWrapper::CreateCriticalSection()),
     _master(master),
@@ -81,6 +84,7 @@ VCMJitterBuffer::VCMJitterBuffer(WebRtc_Word32 vcmId, WebRtc_Word32 receiverId,
     _numConsecutiveOldPackets(0),
     _discardedPackets(0),
     _jitterEstimate(vcmId, receiverId),
+    _delayEstimate(_clock->MillisecondTimestamp()),
     _rttMs(0),
     _nackMode(kNoNack),
     _lowRttNackThresholdMs(-1),
@@ -180,7 +184,7 @@ VCMJitterBuffer::Start()
     _incomingFrameCount = 0;
     _incomingFrameRate = 0;
     _incomingBitCount = 0;
-    _timeLastIncomingFrameCount = VCMTickTime::MillisecondTimestamp();
+    _timeLastIncomingFrameCount = _clock->MillisecondTimestamp();
     memset(_receiveStatistics, 0, sizeof(_receiveStatistics));
 
     _numConsecutiveOldFrames = 0;
@@ -262,7 +266,7 @@ VCMJitterBuffer::FlushInternal()
 
     // Also reset the jitter and delay estimates
     _jitterEstimate.Reset();
-    _delayEstimate.Reset();
+    _delayEstimate.Reset(_clock->MillisecondTimestamp());
 
     _waitingForCompletion.frameSize = 0;
     _waitingForCompletion.timestamp = 0;
@@ -607,7 +611,7 @@ WebRtc_Word32
 VCMJitterBuffer::GetUpdate(WebRtc_UWord32& frameRate, WebRtc_UWord32& bitRate)
 {
     CriticalSectionScoped cs(_critSect);
-    const WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
+    const WebRtc_Word64 now = _clock->MillisecondTimestamp();
     WebRtc_Word64 diff = now - _timeLastIncomingFrameCount;
     if (diff < 1000 && _incomingFrameRate > 0 && _incomingBitRate > 0)
     {
@@ -662,7 +666,7 @@ VCMJitterBuffer::GetUpdate(WebRtc_UWord32& frameRate, WebRtc_UWord32& bitRate)
     else
     {
         // No frames since last call
-        _timeLastIncomingFrameCount = VCMTickTime::MillisecondTimestamp();
+        _timeLastIncomingFrameCount = _clock->MillisecondTimestamp();
         frameRate = 0;
         bitRate = 0;
         _incomingBitRate = 0;
@@ -703,7 +707,7 @@ VCMJitterBuffer::GetCompleteFrameForDecoding(WebRtc_UWord32 maxWaitTimeMS)
             _critSect->Leave();
             return NULL;
         }
-        const WebRtc_Word64 endWaitTimeMs = VCMTickTime::MillisecondTimestamp()
+        const WebRtc_Word64 endWaitTimeMs = _clock->MillisecondTimestamp()
                                             + maxWaitTimeMS;
         WebRtc_Word64 waitTimeMs = maxWaitTimeMS;
         while (waitTimeMs > 0)
@@ -732,7 +736,7 @@ VCMJitterBuffer::GetCompleteFrameForDecoding(WebRtc_UWord32 maxWaitTimeMS)
                 if (oldestFrame == NULL)
                 {
                     waitTimeMs = endWaitTimeMs -
-                                 VCMTickTime::MillisecondTimestamp();
+                                 _clock->MillisecondTimestamp();
                 }
                 else
                 {
@@ -1519,7 +1523,7 @@ VCMFrameBufferEnum
 VCMJitterBuffer::InsertPacket(VCMEncodedFrame* buffer, const VCMPacket& packet)
 {
     CriticalSectionScoped cs(_critSect);
-    WebRtc_Word64 nowMs = VCMTickTime::MillisecondTimestamp();
+    WebRtc_Word64 nowMs = _clock->MillisecondTimestamp();
     VCMFrameBufferEnum bufferReturn = kSizeError;
     VCMFrameBufferEnum ret = kSizeError;
     VCMFrameBuffer* frame = static_cast<VCMFrameBuffer*>(buffer);
@@ -1530,7 +1534,7 @@ VCMJitterBuffer::InsertPacket(VCMEncodedFrame* buffer, const VCMPacket& packet)
     {
         // Now it's time to start estimating jitter
         // reset the delay estimate.
-        _delayEstimate.Reset();
+        _delayEstimate.Reset(_clock->MillisecondTimestamp());
         _firstPacket = false;
     }
 

src/modules/video_coding/main/source/jitter_buffer.h

@@ -33,6 +33,7 @@ enum VCMNackMode
 };
 
 // forward declarations
+class TickTimeBase;
 class VCMFrameBuffer;
 class VCMPacket;
 class VCMEncodedFrame;
@@ -49,7 +50,8 @@ public:
 class VCMJitterBuffer
 {
 public:
-    VCMJitterBuffer(WebRtc_Word32 vcmId = -1,
+    VCMJitterBuffer(TickTimeBase* clock,
+                    WebRtc_Word32 vcmId = -1,
                     WebRtc_Word32 receiverId = -1,
                     bool master = true);
     virtual ~VCMJitterBuffer();
@@ -191,6 +193,7 @@ private:
 
     WebRtc_Word32                 _vcmId;
     WebRtc_Word32                 _receiverId;
+    TickTimeBase*                 _clock;
     // If we are running (have started) or not
     bool                          _running;
     CriticalSectionWrapper*       _critSect;

src/modules/video_coding/main/source/jitter_estimator.cc

@@ -12,8 +12,8 @@
 #include "internal_defines.h"
 #include "jitter_estimator.h"
 #include "rtt_filter.h"
-#include "tick_time.h"
 
+#include <assert.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>

src/modules/video_coding/main/source/media_opt_util.cc

@@ -577,7 +577,7 @@ VCMFecMethod::UpdateParameters(const VCMProtectionParameters* parameters)
 
     return true;
 }
-VCMLossProtectionLogic::VCMLossProtectionLogic():
+VCMLossProtectionLogic::VCMLossProtectionLogic(int64_t nowMs):
 _selectedMethod(NULL),
 _currentParameters(),
 _rtt(0),
@@ -599,7 +599,7 @@ _codecWidth(0),
 _codecHeight(0),
 _numLayers(1)
 {
-    Reset();
+    Reset(nowMs);
 }
 
 VCMLossProtectionLogic::~VCMLossProtectionLogic()
@@ -688,13 +688,13 @@ VCMLossProtectionLogic::UpdateResidualPacketLoss(float residualPacketLoss)
 }
 
 void
-VCMLossProtectionLogic::UpdateLossPr(WebRtc_UWord8 lossPr255)
+VCMLossProtectionLogic::UpdateLossPr(WebRtc_UWord8 lossPr255,
+                                     int64_t nowMs)
 {
-    const WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
+    UpdateMaxLossHistory(lossPr255, nowMs);
-    UpdateMaxLossHistory(lossPr255, now);
+    _lossPr255.Apply(static_cast<float> (nowMs - _lastPrUpdateT),
-    _lossPr255.Apply(static_cast<float> (now - _lastPrUpdateT),
                      static_cast<float> (lossPr255));
-    _lastPrUpdateT = now;
+    _lastPrUpdateT = nowMs;
     _lossPr = _lossPr255.Value() / 255.0f;
 }
 
@@ -768,14 +768,14 @@ VCMLossProtectionLogic::MaxFilteredLossPr(WebRtc_Word64 nowMs) const
 }
 
 WebRtc_UWord8
-VCMLossProtectionLogic::FilteredLoss() const
+VCMLossProtectionLogic::FilteredLoss(int64_t nowMs) const
 {
     if (_selectedMethod != NULL &&
         (_selectedMethod->Type() == kFec ||
          _selectedMethod->Type() == kNackFec))
     {
         // Take the windowed max of the received loss.
-        return MaxFilteredLossPr(VCMTickTime::MillisecondTimestamp());
+        return MaxFilteredLossPr(nowMs);
     }
     else
     {
@@ -797,21 +797,19 @@ VCMLossProtectionLogic::UpdateBitRate(float bitRate)
 }
 
 void
-VCMLossProtectionLogic::UpdatePacketsPerFrame(float nPackets)
+VCMLossProtectionLogic::UpdatePacketsPerFrame(float nPackets, int64_t nowMs)
 {
-    const WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
+    _packetsPerFrame.Apply(static_cast<float>(nowMs - _lastPacketPerFrameUpdateT),
-    _packetsPerFrame.Apply(static_cast<float>(now - _lastPacketPerFrameUpdateT),
                            nPackets);
-    _lastPacketPerFrameUpdateT = now;
+    _lastPacketPerFrameUpdateT = nowMs;
 }
 
 void
-VCMLossProtectionLogic::UpdatePacketsPerFrameKey(float nPackets)
+VCMLossProtectionLogic::UpdatePacketsPerFrameKey(float nPackets, int64_t nowMs)
 {
-    const WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
+    _packetsPerFrameKey.Apply(static_cast<float>(nowMs -
-    _packetsPerFrameKey.Apply(static_cast<float>(now -
                               _lastPacketPerFrameUpdateTKey), nPackets);
-    _lastPacketPerFrameUpdateTKey = now;
+    _lastPacketPerFrameUpdateTKey = nowMs;
 }
 
 void
@@ -868,12 +866,11 @@ VCMLossProtectionLogic::SelectedType() const
 }
 
 void
-VCMLossProtectionLogic::Reset()
+VCMLossProtectionLogic::Reset(int64_t nowMs)
 {
-    const WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
+    _lastPrUpdateT = nowMs;
-    _lastPrUpdateT = now;
+    _lastPacketPerFrameUpdateT = nowMs;
-    _lastPacketPerFrameUpdateT = now;
+    _lastPacketPerFrameUpdateTKey = nowMs;
-    _lastPacketPerFrameUpdateTKey = now;
     _lossPr255.Reset(0.9999f);
     _packetsPerFrame.Reset(0.9999f);
     _fecRateDelta = _fecRateKey = 0;

src/modules/video_coding/main/source/media_opt_util.h

@@ -15,7 +15,6 @@
 #include "trace.h"
 #include "exp_filter.h"
 #include "internal_defines.h"
-#include "tick_time.h"
 #include "qm_select.h"
 
 #include <cmath>
@@ -216,7 +215,7 @@ private:
 class VCMLossProtectionLogic
 {
 public:
-    VCMLossProtectionLogic();
+    VCMLossProtectionLogic(int64_t nowMs);
     ~VCMLossProtectionLogic();
 
     // Set the protection method to be used
@@ -255,7 +254,7 @@ public:
     // Input:
     //          - lossPr255        : The packet loss probability [0, 255],
     //                               reported by RTCP.
-    void UpdateLossPr(WebRtc_UWord8 lossPr255);
+    void UpdateLossPr(WebRtc_UWord8 lossPr255, int64_t nowMs);
 
     // Update the filtered packet loss.
     //
@@ -274,13 +273,13 @@ public:
     //
     // Input:
     //          - nPackets         : Number of packets in the latest sent frame.
-    void UpdatePacketsPerFrame(float nPackets);
+    void UpdatePacketsPerFrame(float nPackets, int64_t nowMs);
 
    // Update the number of packets per frame estimate, for key frames
     //
     // Input:
     //          - nPackets         : umber of packets in the latest sent frame.
-    void UpdatePacketsPerFrameKey(float nPackets);
+    void UpdatePacketsPerFrameKey(float nPackets, int64_t nowMs);
 
     // Update the keyFrameSize estimate
     //
@@ -334,9 +333,9 @@ public:
     // Returns the filtered loss probability in the interval [0, 255].
     //
     // Return value                 : The filtered loss probability
-    WebRtc_UWord8 FilteredLoss() const;
+    WebRtc_UWord8 FilteredLoss(int64_t nowMs) const;
 
-    void Reset();
+    void Reset(int64_t nowMs);
 
     void Release();
 

src/modules/video_coding/main/source/media_optimization.cc

@@ -12,11 +12,14 @@
 #include "content_metrics_processing.h"
 #include "frame_dropper.h"
 #include "qm_select.h"
+#include "modules/video_coding/main/source/tick_time_base.h"
 
 namespace webrtc {
 
-VCMMediaOptimization::VCMMediaOptimization(WebRtc_Word32 id):
+VCMMediaOptimization::VCMMediaOptimization(WebRtc_Word32 id,
+                                           TickTimeBase* clock):
 _id(id),
+_clock(clock),
 _maxBitRate(0),
 _sendCodecType(kVideoCodecUnknown),
 _codecWidth(0),
@@ -43,7 +46,7 @@ _numLayers(0)
     memset(_incomingFrameTimes, -1, sizeof(_incomingFrameTimes));
 
     _frameDropper  = new VCMFrameDropper(_id);
-    _lossProtLogic = new VCMLossProtectionLogic();
+    _lossProtLogic = new VCMLossProtectionLogic(_clock->MillisecondTimestamp());
     _content = new VCMContentMetricsProcessing();
     _qmResolution = new VCMQmResolution();
 }
@@ -63,12 +66,12 @@ VCMMediaOptimization::Reset()
     memset(_incomingFrameTimes, -1, sizeof(_incomingFrameTimes));
     InputFrameRate(); // Resets _incomingFrameRate
     _frameDropper->Reset();
-    _lossProtLogic->Reset();
+    _lossProtLogic->Reset(_clock->MillisecondTimestamp());
     _frameDropper->SetRates(0, 0);
     _content->Reset();
     _qmResolution->Reset();
     _lossProtLogic->UpdateFrameRate(_incomingFrameRate);
-    _lossProtLogic->Reset();
+    _lossProtLogic->Reset(_clock->MillisecondTimestamp());
     _sendStatisticsZeroEncode = 0;
     _targetBitRate = 0;
     _codecWidth = 0;
@@ -95,7 +98,7 @@ VCMMediaOptimization::SetTargetRates(WebRtc_UWord32 bitRate,
 {
     VCMProtectionMethod *selectedMethod = _lossProtLogic->SelectedMethod();
     _lossProtLogic->UpdateBitRate(static_cast<float>(bitRate));
-    _lossProtLogic->UpdateLossPr(fractionLost);
+    _lossProtLogic->UpdateLossPr(fractionLost, _clock->MillisecondTimestamp());
     _lossProtLogic->UpdateRtt(roundTripTimeMs);
     _lossProtLogic->UpdateResidualPacketLoss(static_cast<float>(fractionLost));
 
@@ -118,7 +121,8 @@ VCMMediaOptimization::SetTargetRates(WebRtc_UWord32 bitRate,
     // average or max filter may be used.
     // We should think about which filter is appropriate for low/high bit rates,
     // low/high loss rates, etc.
-    WebRtc_UWord8 packetLossEnc = _lossProtLogic->FilteredLoss();
+    WebRtc_UWord8 packetLossEnc = _lossProtLogic->FilteredLoss(
+        _clock->MillisecondTimestamp());
 
     // For now use the filtered loss for computing the robustness settings
     _lossProtLogic->UpdateFilteredLossPr(packetLossEnc);
@@ -261,7 +265,7 @@ VCMMediaOptimization::SetEncodingData(VideoCodecType sendCodecType,
     // has changed. If native dimension values have changed, then either user
     // initiated change, or QM initiated change. Will be able to determine only
     // after the processing of the first frame.
-    _lastChangeTime = VCMTickTime::MillisecondTimestamp();
+    _lastChangeTime = _clock->MillisecondTimestamp();
     _content->Reset();
     _content->UpdateFrameRate(frameRate);
 
@@ -346,7 +350,7 @@ VCMMediaOptimization::SentFrameRate()
 float
 VCMMediaOptimization::SentBitRate()
 {
-    UpdateBitRateEstimate(-1, VCMTickTime::MillisecondTimestamp());
+    UpdateBitRateEstimate(-1, _clock->MillisecondTimestamp());
     return _avgSentBitRateBps / 1000.0f;
 }
 
@@ -361,7 +365,7 @@ VCMMediaOptimization::UpdateWithEncodedData(WebRtc_Word32 encodedLength,
                                             FrameType encodedFrameType)
 {
     // look into the ViE version - debug mode - needs also number of layers.
-    UpdateBitRateEstimate(encodedLength, VCMTickTime::MillisecondTimestamp());
+    UpdateBitRateEstimate(encodedLength, _clock->MillisecondTimestamp());
     if(encodedLength > 0)
     {
         const bool deltaFrame = (encodedFrameType != kVideoFrameKey &&
@@ -374,11 +378,13 @@ VCMMediaOptimization::UpdateWithEncodedData(WebRtc_Word32 encodedLength,
                                              static_cast<float>(_maxPayloadSize);
             if (deltaFrame)
             {
-                _lossProtLogic->UpdatePacketsPerFrame(minPacketsPerFrame);
+                _lossProtLogic->UpdatePacketsPerFrame(
+                    minPacketsPerFrame, _clock->MillisecondTimestamp());
             }
             else
             {
-                _lossProtLogic->UpdatePacketsPerFrameKey(minPacketsPerFrame);
+                _lossProtLogic->UpdatePacketsPerFrameKey(
+                    minPacketsPerFrame, _clock->MillisecondTimestamp());
             }
 
             if (_enableQm)
@@ -529,7 +535,7 @@ VCMMediaOptimization::SelectQuality()
     _qmResolution->ResetRates();
 
     // Reset counters
-    _lastQMUpdateTime = VCMTickTime::MillisecondTimestamp();
+    _lastQMUpdateTime = _clock->MillisecondTimestamp();
 
     // Reset content metrics
     _content->Reset();
@@ -552,7 +558,7 @@ VCMMediaOptimization::checkStatusForQMchange()
     // (to sample the metrics) from the event lastChangeTime
     // lastChangeTime is the time where user changed the size/rate/frame rate
     // (via SetEncodingData)
-    WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
+    WebRtc_Word64 now = _clock->MillisecondTimestamp();
     if ((now - _lastQMUpdateTime) < kQmMinIntervalMs ||
         (now  - _lastChangeTime) <  kQmMinIntervalMs)
     {
@@ -622,7 +628,7 @@ VCMMediaOptimization::QMUpdate(VCMResolutionScale* qm)
 void
 VCMMediaOptimization::UpdateIncomingFrameRate()
 {
-    WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
+    WebRtc_Word64 now = _clock->MillisecondTimestamp();
     if (_incomingFrameTimes[0] == 0)
     {
         // first no shift
@@ -674,7 +680,7 @@ VCMMediaOptimization::ProcessIncomingFrameRate(WebRtc_Word64 now)
 WebRtc_UWord32
 VCMMediaOptimization::InputFrameRate()
 {
-    ProcessIncomingFrameRate(VCMTickTime::MillisecondTimestamp());
+    ProcessIncomingFrameRate(_clock->MillisecondTimestamp());
     return WebRtc_UWord32 (_incomingFrameRate + 0.5f);
 }
 

src/modules/video_coding/main/source/media_optimization.h

@@ -24,6 +24,7 @@ namespace webrtc
 enum { kBitrateMaxFrameSamples = 60 };
 enum { kBitrateAverageWinMs    = 1000 };
 
+class TickTimeBase;
 class VCMContentMetricsProcessing;
 class VCMFrameDropper;
 
@@ -38,7 +39,7 @@ struct VCMEncodedFrameSample
 class VCMMediaOptimization
 {
 public:
-    VCMMediaOptimization(WebRtc_Word32 id);
+    VCMMediaOptimization(WebRtc_Word32 id, TickTimeBase* clock);
     ~VCMMediaOptimization(void);
     /*
     * Reset the Media Optimization module
@@ -163,7 +164,7 @@ private:
     enum { kFrameHistoryWinMs = 2000};
 
     WebRtc_Word32                     _id;
-
+    TickTimeBase*                     _clock;
     WebRtc_Word32                     _maxBitRate;
     VideoCodecType                    _sendCodecType;
     WebRtc_UWord16                    _codecWidth;

src/modules/video_coding/main/source/mock/fake_tick_time.h

@@ -8,33 +8,40 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#ifndef WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_MOCK_FAKE_TICK_TIME_WRAPPER_H_
+#ifndef WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_MOCK_FAKE_TICK_TIME_H_
-#define WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_MOCK_FAKE_TICK_TIME_WRAPPER_H_
+#define WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_MOCK_FAKE_TICK_TIME_H_
 
-#include "modules/video_coding/main/source/tick_time_interface.h"
+#include <assert.h>
+
+#include <limits>
+
+#include "modules/video_coding/main/source/tick_time_base.h"
 
 namespace webrtc {
 
-class FakeTickTime : public TickTimeInterface {
+// Provides a fake implementation of TickTimeBase, intended for offline
+// testing. This implementation does not query the system clock, but returns a
+// time value set by the user when creating the object, and incremented with
+// the method IncrementDebugClock.
+class FakeTickTime : public TickTimeBase {
  public:
-  explicit FakeTickTime(int64_t start_time_ms) : fake_now_(TickTime::Now()) {
+  explicit FakeTickTime(int64_t start_time_ms) : fake_now_ms_(start_time_ms) {}
-    fake_now_ += (MillisecondsToTicks(start_time_ms) - fake_now_.Ticks());
+  virtual ~FakeTickTime() {}
-  }
-  virtual TickTime Now() const { return fake_now_; }
   virtual int64_t MillisecondTimestamp() const {
-    return TicksToMilliseconds(Now().Ticks());
+    return fake_now_ms_;
   }
   virtual int64_t MicrosecondTimestamp() const {
-    return 1000 * TicksToMilliseconds(Now().Ticks());
+    return 1000 * fake_now_ms_;
   }
   virtual void IncrementDebugClock(int64_t increase_ms) {
-    fake_now_ += MillisecondsToTicks(increase_ms);
+    assert(increase_ms <= std::numeric_limits<int64_t>::max() - fake_now_ms_);
+    fake_now_ms_ += increase_ms;
   }
 
  private:
-  TickTime fake_now_;
+  int64_t fake_now_ms_;
 };
 
 }  // namespace
 
-#endif  // WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_MOCK_FAKE_TICK_TIME_WRAPPER_H_
+#endif  // WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_MOCK_FAKE_TICK_TIME_H_

src/modules/video_coding/main/source/receiver.cc

@@ -13,7 +13,7 @@
 #include "encoded_frame.h"
 #include "internal_defines.h"
 #include "media_opt_util.h"
-#include "tick_time.h"
+#include "tick_time_base.h"
 #include "trace.h"
 #include "video_coding.h"
 
@@ -22,15 +22,17 @@
 namespace webrtc {
 
 VCMReceiver::VCMReceiver(VCMTiming& timing,
+                         TickTimeBase* clock,
                          WebRtc_Word32 vcmId,
                          WebRtc_Word32 receiverId,
                          bool master)
 :
 _critSect(CriticalSectionWrapper::CreateCriticalSection()),
 _vcmId(vcmId),
+_clock(clock),
 _receiverId(receiverId),
 _master(master),
-_jitterBuffer(vcmId, receiverId, master),
+_jitterBuffer(_clock, vcmId, receiverId, master),
 _timing(timing),
 _renderWaitEvent(*new VCMEvent()),
 _state(kPassive)
@@ -118,10 +120,10 @@ VCMReceiver::InsertPacket(const VCMPacket& packet,
                          VCMId(_vcmId, _receiverId),
                          "Packet seqNo %u of frame %u at %u",
                          packet.seqNum, packet.timestamp,
-                         MaskWord64ToUWord32(VCMTickTime::MillisecondTimestamp()));
+                         MaskWord64ToUWord32(_clock->MillisecondTimestamp()));
         }
 
-        const WebRtc_Word64 nowMs = VCMTickTime::MillisecondTimestamp();
+        const WebRtc_Word64 nowMs = _clock->MillisecondTimestamp();
 
         WebRtc_Word64 renderTimeMs = _timing.RenderTimeMs(packet.timestamp, nowMs);
 
@@ -130,7 +132,7 @@ VCMReceiver::InsertPacket(const VCMPacket& packet,
             // Render time error. Assume that this is due to some change in
             // the incoming video stream and reset the JB and the timing.
             _jitterBuffer.Flush();
-            _timing.Reset();
+            _timing.Reset(_clock->MillisecondTimestamp());
             return VCM_FLUSH_INDICATOR;
         }
         else if (renderTimeMs < nowMs - kMaxVideoDelayMs)
@@ -139,7 +141,7 @@ VCMReceiver::InsertPacket(const VCMPacket& packet,
                 "This frame should have been rendered more than %u ms ago."
                 "Flushing jitter buffer and resetting timing.", kMaxVideoDelayMs);
             _jitterBuffer.Flush();
-            _timing.Reset();
+            _timing.Reset(_clock->MillisecondTimestamp());
             return VCM_FLUSH_INDICATOR;
         }
         else if (_timing.TargetVideoDelay() > kMaxVideoDelayMs)
@@ -148,14 +150,14 @@ VCMReceiver::InsertPacket(const VCMPacket& packet,
                 "More than %u ms target delay. Flushing jitter buffer and resetting timing.",
                 kMaxVideoDelayMs);
             _jitterBuffer.Flush();
-            _timing.Reset();
+            _timing.Reset(_clock->MillisecondTimestamp());
             return VCM_FLUSH_INDICATOR;
         }
 
         // First packet received belonging to this frame.
         if (buffer->Length() == 0)
         {
-            const WebRtc_Word64 nowMs = VCMTickTime::MillisecondTimestamp();
+            const WebRtc_Word64 nowMs = _clock->MillisecondTimestamp();
             if (_master)
             {
                 // Only trace the primary receiver to make it possible to parse and plot the trace file.
@@ -199,7 +201,7 @@ VCMReceiver::FrameForDecoding(WebRtc_UWord16 maxWaitTimeMs, WebRtc_Word64& nextR
     // is thread-safe.
     FrameType incomingFrameType = kVideoFrameDelta;
     nextRenderTimeMs = -1;
-    const WebRtc_Word64 startTimeMs = VCMTickTime::MillisecondTimestamp();
+    const WebRtc_Word64 startTimeMs = _clock->MillisecondTimestamp();
     WebRtc_Word64 ret = _jitterBuffer.GetNextTimeStamp(maxWaitTimeMs,
                                                        incomingFrameType,
                                                        nextRenderTimeMs);
@@ -215,7 +217,7 @@ VCMReceiver::FrameForDecoding(WebRtc_UWord16 maxWaitTimeMs, WebRtc_Word64& nextR
     _timing.UpdateCurrentDelay(timeStamp);
 
     const WebRtc_Word32 tempWaitTime = maxWaitTimeMs -
-            static_cast<WebRtc_Word32>(VCMTickTime::MillisecondTimestamp() - startTimeMs);
+            static_cast<WebRtc_Word32>(_clock->MillisecondTimestamp() - startTimeMs);
     WebRtc_UWord16 newMaxWaitTime = static_cast<WebRtc_UWord16>(VCM_MAX(tempWaitTime, 0));
 
     VCMEncodedFrame* frame = NULL;
@@ -256,7 +258,7 @@ VCMReceiver::FrameForDecoding(WebRtc_UWord16 maxWaitTimeMs,
 {
     // How long can we wait until we must decode the next frame
     WebRtc_UWord32 waitTimeMs = _timing.MaxWaitingTime(nextRenderTimeMs,
-                                          VCMTickTime::MillisecondTimestamp());
+                                          _clock->MillisecondTimestamp());
 
     // Try to get a complete frame from the jitter buffer
     VCMEncodedFrame* frame = _jitterBuffer.GetCompleteFrameForDecoding(0);
@@ -296,7 +298,7 @@ VCMReceiver::FrameForDecoding(WebRtc_UWord16 maxWaitTimeMs,
     {
         // Get an incomplete frame
         if (_timing.MaxWaitingTime(nextRenderTimeMs,
-                                   VCMTickTime::MillisecondTimestamp()) > 0)
+                                   _clock->MillisecondTimestamp()) > 0)
         {
             // Still time to wait for a complete frame
             return NULL;
@@ -328,7 +330,7 @@ VCMReceiver::FrameForRendering(WebRtc_UWord16 maxWaitTimeMs,
     // as possible before giving the frame to the decoder, which will render the frame as soon
     // as it has been decoded.
     WebRtc_UWord32 waitTimeMs = _timing.MaxWaitingTime(nextRenderTimeMs,
-                                                       VCMTickTime::MillisecondTimestamp());
+                                                       _clock->MillisecondTimestamp());
     if (maxWaitTimeMs < waitTimeMs)
     {
         // If we're not allowed to wait until the frame is supposed to be rendered

src/modules/video_coding/main/source/receiver.h

@@ -13,6 +13,7 @@
 
 #include "critical_section_wrapper.h"
 #include "jitter_buffer.h"
+#include "modules/video_coding/main/source/tick_time_base.h"
 #include "timing.h"
 #include "packet.h"
 
@@ -40,6 +41,7 @@ class VCMReceiver
 {
 public:
     VCMReceiver(VCMTiming& timing,
+                TickTimeBase* clock,
                 WebRtc_Word32 vcmId = -1,
                 WebRtc_Word32 receiverId = -1,
                 bool master = true);
@@ -83,6 +85,7 @@ private:
 
     CriticalSectionWrapper* _critSect;
     WebRtc_Word32           _vcmId;
+    TickTimeBase*           _clock;
     WebRtc_Word32           _receiverId;
     bool                    _master;
     VCMJitterBuffer         _jitterBuffer;

src/modules/video_coding/main/source/tick_time.h

@@ -1,55 +0,0 @@
-/*
- *  Copyright (c) 2011 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.
- */
-
-#ifndef WEBRTC_MODULES_VIDEO_CODING_TICK_TIME_H_
-#define WEBRTC_MODULES_VIDEO_CODING_TICK_TIME_H_
-
-#include "tick_util.h"
-
-#include <assert.h>
-
-namespace webrtc
-{
-
-//#define TICK_TIME_DEBUG
-
-class VCMTickTime : public TickTime
-{
-#ifdef TICK_TIME_DEBUG
-public:
-    /*
-    *   Get current time
-    */
-    static TickTime Now() { assert(false); };
-
-    /*
-    *   Get time in milli seconds
-    */
-    static WebRtc_Word64 MillisecondTimestamp() { return _timeNowDebug; };
-
-    /*
-    *   Get time in micro seconds
-    */
-    static WebRtc_Word64 MicrosecondTimestamp() { return _timeNowDebug * 1000LL; };
-
-    static void IncrementDebugClock() { _timeNowDebug++; };
-
-private:
-    static WebRtc_Word64     _timeNowDebug;
-
-#else
-public:
-    static void IncrementDebugClock() { assert(false); };
-#endif
-};
-
-} // namespace webrtc
-
-#endif // WEBRTC_MODULES_VIDEO_CODING_TICK_TIME_H_

src/modules/video_coding/main/source/tick_time_base.h

@@ -8,24 +8,24 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#ifndef WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_TICK_TIME_WRAPPER_H_
+#ifndef WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_TICK_TIME_BASE_H_
-#define WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_TICK_TIME_WRAPPER_H_
+#define WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_TICK_TIME_BASE_H_
 
 #include "system_wrappers/interface/tick_util.h"
 
 namespace webrtc {
 
-class TickTimeInterface : public TickTime {
+// This class provides a mockable wrapper to TickTime.
+class TickTimeBase {
  public:
-  // Current time in the tick domain.
+  virtual ~TickTimeBase() {}
-  virtual TickTime Now() const { return TickTime::Now(); }
 
-  // Now in the time domain in ms.
+  // "Now" in milliseconds.
   virtual int64_t MillisecondTimestamp() const {
     return TickTime::MillisecondTimestamp();
   }
 
-  // Now in the time domain in us.
+  // "Now" in microseconds.
   virtual int64_t MicrosecondTimestamp() const {
     return TickTime::MicrosecondTimestamp();
   }
@@ -33,4 +33,4 @@ class TickTimeInterface : public TickTime {
 
 }  // namespace
 
-#endif  // WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_TICK_TIME_WRAPPER_H_
+#endif  // WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_TICK_TIME_BASE_H_

src/modules/video_coding/main/source/timestamp_extrapolator.cc

@@ -9,17 +9,20 @@
  */
 
 #include "internal_defines.h"
+#include "modules/video_coding/main/source/tick_time_base.h"
 #include "timestamp_extrapolator.h"
-#include "tick_time.h"
 #include "trace.h"
 
 namespace webrtc {
 
-VCMTimestampExtrapolator::VCMTimestampExtrapolator(WebRtc_Word32 vcmId, WebRtc_Word32 id)
+VCMTimestampExtrapolator::VCMTimestampExtrapolator(TickTimeBase* clock,
+                                                   WebRtc_Word32 vcmId,
+                                                   WebRtc_Word32 id)
 :
 _rwLock(RWLockWrapper::CreateRWLock()),
 _vcmId(vcmId),
 _id(id),
+_clock(clock),
 _startMs(0),
 _firstTimestamp(0),
 _wrapArounds(0),
@@ -35,7 +38,7 @@ _accDrift(6600), // in timestamp ticks, i.e. 15 ms
 _accMaxError(7000),
 _P11(1e10)
 {
-    Reset(VCMTickTime::MillisecondTimestamp());
+    Reset(_clock->MillisecondTimestamp());
 }
 
 VCMTimestampExtrapolator::~VCMTimestampExtrapolator()
@@ -53,7 +56,7 @@ VCMTimestampExtrapolator::Reset(const WebRtc_Word64 nowMs /* = -1 */)
     }
     else
     {
-        _startMs = VCMTickTime::MillisecondTimestamp();
+        _startMs = _clock->MillisecondTimestamp();
     }
     _prevMs = _startMs;
     _firstTimestamp = 0;

src/modules/video_coding/main/source/timestamp_extrapolator.h

@@ -17,10 +17,14 @@
 namespace webrtc
 {
 
+class TickTimeBase;
+
 class VCMTimestampExtrapolator
 {
 public:
-    VCMTimestampExtrapolator(WebRtc_Word32 vcmId = 0, WebRtc_Word32 receiverId = 0);
+    VCMTimestampExtrapolator(TickTimeBase* clock,
+                             WebRtc_Word32 vcmId = 0,
+                             WebRtc_Word32 receiverId = 0);
     ~VCMTimestampExtrapolator();
     void Update(WebRtc_Word64 tMs, WebRtc_UWord32 ts90khz, bool trace = true);
     WebRtc_UWord32 ExtrapolateTimestamp(WebRtc_Word64 tMs) const;
@@ -33,6 +37,7 @@ private:
     RWLockWrapper*        _rwLock;
     WebRtc_Word32         _vcmId;
     WebRtc_Word32         _id;
+    TickTimeBase*         _clock;
     bool                _trace;
     double              _w[2];
     double              _P[2][2];

src/modules/video_coding/main/source/timing.cc

@@ -16,10 +16,14 @@
 
 namespace webrtc {
 
-VCMTiming::VCMTiming(WebRtc_Word32 vcmId, WebRtc_Word32 timingId, VCMTiming* masterTiming)
+VCMTiming::VCMTiming(TickTimeBase* clock,
+                     WebRtc_Word32 vcmId,
+                     WebRtc_Word32 timingId,
+                     VCMTiming* masterTiming)
 :
 _critSect(CriticalSectionWrapper::CreateCriticalSection()),
 _vcmId(vcmId),
+_clock(clock),
 _timingId(timingId),
 _master(false),
 _tsExtrapolator(),
@@ -33,7 +37,7 @@ _prevFrameTimestamp(0)
     if (masterTiming == NULL)
     {
         _master = true;
-        _tsExtrapolator = new VCMTimestampExtrapolator(vcmId, timingId);
+        _tsExtrapolator = new VCMTimestampExtrapolator(_clock, vcmId, timingId);
     }
     else
     {

src/modules/video_coding/main/source/timing.h

@@ -18,6 +18,7 @@
 namespace webrtc
 {
 
+class TickTimeBase;
 class VCMTimestampExtrapolator;
 
 class VCMTiming
@@ -25,7 +26,8 @@ class VCMTiming
 public:
     // The primary timing component should be passed
     // if this is the dual timing component.
-    VCMTiming(WebRtc_Word32 vcmId = 0,
+    VCMTiming(TickTimeBase* clock,
+              WebRtc_Word32 vcmId = 0,
               WebRtc_Word32 timingId = 0,
               VCMTiming* masterTiming = NULL);
     ~VCMTiming();
@@ -92,6 +94,7 @@ protected:
 private:
     CriticalSectionWrapper*       _critSect;
     WebRtc_Word32                 _vcmId;
+    TickTimeBase*                 _clock;
     WebRtc_Word32                 _timingId;
     bool                          _master;
     VCMTimestampExtrapolator*     _tsExtrapolator;

src/modules/video_coding/main/source/video_coding.gypi

@@ -63,8 +63,7 @@
         'receiver.h',
         'rtt_filter.h',
         'session_info.h',
-        'tick_time.h',
+        'tick_time_base.h',
-        'tick_time_interface.h',
         'timestamp_extrapolator.h',
         'timestamp_map.h',
         'timing.h',

src/modules/video_coding/main/source/video_coding_impl.cc

@@ -15,6 +15,7 @@
 #include "packet.h"
 #include "trace.h"
 #include "video_codec_interface.h"
+#include "modules/video_coding/main/source/tick_time_base.h"
 
 namespace webrtc
 {
@@ -33,26 +34,30 @@ VCMProcessTimer::TimeUntilProcess() const
 {
     return static_cast<WebRtc_UWord32>(
         VCM_MAX(static_cast<WebRtc_Word64>(_periodMs) -
-                (VCMTickTime::MillisecondTimestamp() - _latestMs), 0));
+                (_clock->MillisecondTimestamp() - _latestMs), 0));
 }
 
 void
 VCMProcessTimer::Processed()
 {
-    _latestMs = VCMTickTime::MillisecondTimestamp();
+    _latestMs = _clock->MillisecondTimestamp();
 }
 
-VideoCodingModuleImpl::VideoCodingModuleImpl(const WebRtc_Word32 id)
+VideoCodingModuleImpl::VideoCodingModuleImpl(const WebRtc_Word32 id,
+                                             TickTimeBase* clock,
+                                             bool delete_clock_on_destroy)
 :
 _id(id),
+clock_(clock),
+delete_clock_on_destroy_(delete_clock_on_destroy),
 _receiveCritSect(CriticalSectionWrapper::CreateCriticalSection()),
 _receiverInited(false),
-_timing(id, 1),
+_timing(clock_, id, 1),
-_dualTiming(id, 2, &_timing),
+_dualTiming(clock_, id, 2, &_timing),
-_receiver(_timing, id, 1),
+_receiver(_timing, clock_, id, 1),
-_dualReceiver(_dualTiming, id, 2, false),
+_dualReceiver(_dualTiming, clock_, id, 2, false),
-_decodedFrameCallback(_timing),
+_decodedFrameCallback(_timing, clock_),
-_dualDecodedFrameCallback(_dualTiming),
+_dualDecodedFrameCallback(_dualTiming, clock_),
 _frameTypeCallback(NULL),
 _frameStorageCallback(NULL),
 _receiveStatsCallback(NULL),
@@ -67,17 +72,18 @@ _scheduleKeyRequest(false),
 _sendCritSect(CriticalSectionWrapper::CreateCriticalSection()),
 _encoder(),
 _encodedFrameCallback(),
-_mediaOpt(id),
+_mediaOpt(id, clock_),
 _sendCodecType(kVideoCodecUnknown),
 _sendStatsCallback(NULL),
 _encoderInputFile(NULL),
 
 _codecDataBase(id),
-_receiveStatsTimer(1000),
+_receiveStatsTimer(1000, clock_),
-_sendStatsTimer(1000),
+_sendStatsTimer(1000, clock_),
-_retransmissionTimer(10),
+_retransmissionTimer(10, clock_),
-_keyRequestTimer(500)
+_keyRequestTimer(500, clock_)
 {
+    assert(clock_);
     for (int i = 0; i < kMaxSimulcastStreams; i++)
     {
         _nextFrameType[i] = kVideoFrameDelta;
@@ -98,6 +104,7 @@ VideoCodingModuleImpl::~VideoCodingModuleImpl()
     }
     delete _receiveCritSect;
     delete _sendCritSect;
+    if (delete_clock_on_destroy_) delete clock_;
 #ifdef DEBUG_DECODER_BIT_STREAM
     fclose(_bitStreamBeforeDecoder);
 #endif
@@ -113,7 +120,18 @@ VideoCodingModule::Create(const WebRtc_Word32 id)
                  webrtc::kTraceVideoCoding,
                  VCMId(id),
                  "VideoCodingModule::Create()");
-    return new VideoCodingModuleImpl(id);
+    return new VideoCodingModuleImpl(id, new TickTimeBase(), true);
+}
+
+VideoCodingModule*
+VideoCodingModule::Create(const WebRtc_Word32 id, TickTimeBase* clock)
+{
+    WEBRTC_TRACE(webrtc::kTraceModuleCall,
+                 webrtc::kTraceVideoCoding,
+                 VCMId(id),
+                 "VideoCodingModule::Create()");
+    assert(clock);
+    return new VideoCodingModuleImpl(id, clock, false);
 }
 
 void
@@ -1089,7 +1107,7 @@ VideoCodingModuleImpl::Decode(WebRtc_UWord16 maxWaitTimeMs)
 
         // If this frame was too late, we should adjust the delay accordingly
         _timing.UpdateCurrentDelay(frame->RenderTimeMs(),
-                                   VCMTickTime::MillisecondTimestamp());
+                                   clock_->MillisecondTimestamp());
 
 #ifdef DEBUG_DECODER_BIT_STREAM
         if (_bitStreamBeforeDecoder != NULL)
@@ -1206,7 +1224,8 @@ VideoCodingModuleImpl::DecodeDualFrame(WebRtc_UWord16 maxWaitTimeMs)
                      "Decoding frame %u with dual decoder",
                      dualFrame->TimeStamp());
         // Decode dualFrame and try to catch up
-        WebRtc_Word32 ret = _dualDecoder->Decode(*dualFrame);
+        WebRtc_Word32 ret = _dualDecoder->Decode(*dualFrame,
+                                                 clock_->MillisecondTimestamp());
         if (ret != WEBRTC_VIDEO_CODEC_OK)
         {
             WEBRTC_TRACE(webrtc::kTraceWarning,
@@ -1254,7 +1273,7 @@ VideoCodingModuleImpl::Decode(const VCMEncodedFrame& frame)
         return VCM_NO_CODEC_REGISTERED;
     }
     // Decode a frame
-    WebRtc_Word32 ret = _decoder->Decode(frame);
+    WebRtc_Word32 ret = _decoder->Decode(frame, clock_->MillisecondTimestamp());
 
     // Check for failed decoding, run frame type request callback if needed.
     if (ret < 0)

src/modules/video_coding/main/source/video_coding_impl.h

@@ -21,6 +21,7 @@
 #include "generic_decoder.h"
 #include "generic_encoder.h"
 #include "media_optimization.h"
+#include "modules/video_coding/main/source/tick_time_base.h"
 
 #include <stdio.h>
 
@@ -30,13 +31,16 @@ namespace webrtc
 class VCMProcessTimer
 {
 public:
-    VCMProcessTimer(WebRtc_UWord32 periodMs) :
+    VCMProcessTimer(WebRtc_UWord32 periodMs, TickTimeBase* clock)
-        _periodMs(periodMs), _latestMs(VCMTickTime::MillisecondTimestamp()) {}
+        : _clock(clock),
+          _periodMs(periodMs),
+          _latestMs(_clock->MillisecondTimestamp()) {}
     WebRtc_UWord32 Period() const;
     WebRtc_UWord32 TimeUntilProcess() const;
     void Processed();
 
 private:
+    TickTimeBase*         _clock;
     WebRtc_UWord32        _periodMs;
     WebRtc_Word64         _latestMs;
 };
@@ -53,7 +57,9 @@ enum VCMKeyRequestMode
 class VideoCodingModuleImpl : public VideoCodingModule
 {
 public:
-    VideoCodingModuleImpl(const WebRtc_Word32 id);
+    VideoCodingModuleImpl(const WebRtc_Word32 id,
+                          TickTimeBase* clock,
+                          bool delete_clock_on_destroy);
 
     virtual ~VideoCodingModuleImpl();
 
@@ -259,6 +265,8 @@ protected:
 
 private:
     WebRtc_Word32                       _id;
+    TickTimeBase*                       clock_;
+    bool                                delete_clock_on_destroy_;
     CriticalSectionWrapper*             _receiveCritSect;
     bool                                _receiverInited;
     VCMTiming                           _timing;

src/modules/video_coding/main/test/decode_from_storage_test.cc

@@ -12,9 +12,9 @@
 #include "video_coding.h"
 #include "rtp_rtcp.h"
 #include "trace.h"
-#include "tick_time.h"
 #include "../source/event.h"
 #include "rtp_player.h"
+#include "modules/video_coding/main/source/mock/fake_tick_time.h"
 
 using namespace webrtc;
 
@@ -35,8 +35,8 @@ private:
 
 int DecodeFromStorageTest(CmdArgs& args)
 {
-    // Make sure this test isn't executed without simulated clocks
+    // Make sure this test isn't executed without simulated events.
-#if !defined(TICK_TIME_DEBUG) || !defined(EVENT_DEBUG)
+#if !defined(EVENT_DEBUG)
     return -1;
 #endif
     // BEGIN Settings
@@ -64,8 +64,10 @@ int DecodeFromStorageTest(CmdArgs& args)
     Trace::SetLevelFilter(webrtc::kTraceAll);
 
 
-    VideoCodingModule* vcm = VideoCodingModule::Create(1);
+    FakeTickTime clock(0);
-    VideoCodingModule* vcmPlayback = VideoCodingModule::Create(2);
+    // TODO(hlundin): This test was not verified after changing to FakeTickTime.
+    VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
+    VideoCodingModule* vcmPlayback = VideoCodingModule::Create(2, &clock);
     FrameStorageCallback storageCallback(vcmPlayback);
     RtpDataCallback dataCallback(vcm);
     WebRtc_Word32 ret = vcm->InitializeReceiver();
@@ -80,7 +82,7 @@ int DecodeFromStorageTest(CmdArgs& args)
     }
     vcm->RegisterFrameStorageCallback(&storageCallback);
     vcmPlayback->RegisterReceiveCallback(&receiveCallback);
-    RTPPlayer rtpStream(rtpFilename.c_str(), &dataCallback);
+    RTPPlayer rtpStream(rtpFilename.c_str(), &dataCallback, &clock);
     ListWrapper payloadTypes;
     payloadTypes.PushFront(new PayloadCodecTuple(VCM_VP8_PAYLOAD_TYPE, "VP8", kVideoCodecVP8));
 
@@ -124,9 +126,9 @@ int DecodeFromStorageTest(CmdArgs& args)
     ret = 0;
 
     // RTP stream main loop
-    while ((ret = rtpStream.NextPacket(VCMTickTime::MillisecondTimestamp())) == 0)
+    while ((ret = rtpStream.NextPacket(clock.MillisecondTimestamp())) == 0)
     {
-        if (VCMTickTime::MillisecondTimestamp() % 5 == 0)
+        if (clock.MillisecondTimestamp() % 5 == 0)
         {
             ret = vcm->Decode();
             if (ret < 0)
@@ -138,11 +140,11 @@ int DecodeFromStorageTest(CmdArgs& args)
         {
             vcm->Process();
         }
-        if (MAX_RUNTIME_MS > -1 && VCMTickTime::MillisecondTimestamp() >= MAX_RUNTIME_MS)
+        if (MAX_RUNTIME_MS > -1 && clock.MillisecondTimestamp() >= MAX_RUNTIME_MS)
         {
             break;
         }
-        VCMTickTime::IncrementDebugClock();
+        clock.IncrementDebugClock(1);
     }
 
     switch (ret)

src/modules/video_coding/main/test/generic_codec_test.cc

@@ -11,11 +11,11 @@
 #include "generic_codec_test.h"
 #include <cmath>
 #include <stdio.h>
-#include "tick_time.h"
 #include "../source/event.h"
 #include "rtp_rtcp.h"
 #include "module_common_types.h"
 #include "test_macros.h"
+#include "modules/video_coding/main/source/mock/fake_tick_time.h"
 
 using namespace webrtc;
 
@@ -23,12 +23,13 @@ enum { kMaxWaitEncTimeMs = 100 };
 
 int GenericCodecTest::RunTest(CmdArgs& args)
 {
-#if !defined(TICK_TIME_DEBUG) || !defined(EVENT_DEBUG)
+#if !defined(EVENT_DEBUG)
-    printf("\n\nEnable debug time to run this test!\n\n");
+    printf("\n\nEnable debug events to run this test!\n\n");
     return -1;
 #endif
-    VideoCodingModule* vcm = VideoCodingModule::Create(1);
+    FakeTickTime clock(0);
-    GenericCodecTest* get = new GenericCodecTest(vcm);
+    VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
+    GenericCodecTest* get = new GenericCodecTest(vcm, &clock);
     Trace::CreateTrace();
     Trace::SetTraceFile(
         (test::OutputPath() + "genericCodecTestTrace.txt").c_str());
@@ -40,7 +41,8 @@ int GenericCodecTest::RunTest(CmdArgs& args)
     return 0;
 }
 
-GenericCodecTest::GenericCodecTest(VideoCodingModule* vcm):
+GenericCodecTest::GenericCodecTest(VideoCodingModule* vcm, FakeTickTime* clock):
+_clock(clock),
 _vcm(vcm),
 _width(0),
 _height(0),
@@ -307,7 +309,7 @@ GenericCodecTest::Perform(CmdArgs& args)
             _vcm->SetChannelParameters((WebRtc_UWord32)_bitRate, 0, 20);
             _frameCnt = 0;
             totalBytes = 0;
-            startTime = VCMTickTime::MicrosecondTimestamp();
+            startTime = _clock->MicrosecondTimestamp();
             _encodeCompleteCallback->Initialize();
             sendStats.SetTargetFrameRate(static_cast<WebRtc_UWord32>(_frameRate));
             _vcm->RegisterSendStatisticsCallback(&sendStats);
@@ -331,7 +333,7 @@ GenericCodecTest::Perform(CmdArgs& args)
                 //currentTime = VCMTickTime::MillisecondTimestamp();//clock()/(double)CLOCKS_PER_SEC;
                 if (_frameCnt == _frameRate)// @ 1sec
                 {
-                    oneSecTime = VCMTickTime::MicrosecondTimestamp();
+                    oneSecTime = _clock->MicrosecondTimestamp();
                     totalBytesOneSec =  _encodeCompleteCallback->EncodedBytes();//totalBytes;
                 }
                 TEST(_vcm->TimeUntilNextProcess() >= 0);
@@ -341,7 +343,7 @@ GenericCodecTest::Perform(CmdArgs& args)
             // estimating rates
             // complete sequence
             // bit rate assumes input frame rate is as specified
-            currentTime = VCMTickTime::MicrosecondTimestamp();
+            currentTime = _clock->MicrosecondTimestamp();
             totalBytes = _encodeCompleteCallback->EncodedBytes();
             actualBitrate = (float)(8.0/1000)*(totalBytes / (_frameCnt / _frameRate));
 
@@ -514,8 +516,8 @@ GenericCodecTest::Print()
 float
 GenericCodecTest::WaitForEncodedFrame() const
 {
-    WebRtc_Word64 startTime = TickTime::MillisecondTimestamp();
+    WebRtc_Word64 startTime = _clock->MillisecondTimestamp();
-    while (TickTime::MillisecondTimestamp() - startTime < kMaxWaitEncTimeMs*10)
+    while (_clock->MillisecondTimestamp() - startTime < kMaxWaitEncTimeMs*10)
     {
         if (_encodeCompleteCallback->EncodeComplete())
         {
@@ -528,11 +530,7 @@ GenericCodecTest::WaitForEncodedFrame() const
 void
 GenericCodecTest::IncrementDebugClock(float frameRate)
 {
-    for (int t= 0; t < 1000/frameRate; t++)
+    _clock->IncrementDebugClock(1000/frameRate);
-    {
-        VCMTickTime::IncrementDebugClock();
-    }
-    return;
 }
 
 int

src/modules/video_coding/main/test/generic_codec_test.h

@@ -31,10 +31,13 @@ namespace webrtc {
 
 int VCMGenericCodecTest(CmdArgs& args);
 
+class FakeTickTime;
+
 class GenericCodecTest
 {
 public:
-    GenericCodecTest(webrtc::VideoCodingModule* vcm);
+    GenericCodecTest(webrtc::VideoCodingModule* vcm,
+                     webrtc::FakeTickTime* clock);
     ~GenericCodecTest();
     static int RunTest(CmdArgs& args);
     WebRtc_Word32 Perform(CmdArgs& args);
@@ -46,6 +49,7 @@ private:
     WebRtc_Word32 TearDown();
     void IncrementDebugClock(float frameRate);
 
+    webrtc::FakeTickTime*                _clock;
     webrtc::VideoCodingModule*           _vcm;
     webrtc::VideoCodec                   _sendCodec;
     webrtc::VideoCodec                   _receiveCodec;

src/modules/video_coding/main/test/jitter_buffer_test.cc

@@ -19,10 +19,10 @@
 #include "jitter_estimate_test.h"
 #include "jitter_estimator.h"
 #include "media_opt_util.h"
+#include "modules/video_coding/main/source/tick_time_base.h"
 #include "packet.h"
 #include "test_util.h"
 #include "test_macros.h"
-#include "tick_time.h"
 
 using namespace webrtc;
 
@@ -92,10 +92,11 @@ int CheckOutFrame(VCMEncodedFrame* frameOut, unsigned int size, bool startCode)
 
 int JitterBufferTest(CmdArgs& args)
 {
-    // Don't run these tests with debug time
+    // Don't run these tests with debug event.
-#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
+#if defined(EVENT_DEBUG)
     return -1;
 #endif
+    TickTimeBase clock;
 
     // Start test
     WebRtc_UWord16 seqNum = 1234;
@@ -114,7 +115,7 @@ int JitterBufferTest(CmdArgs& args)
         packet.seqNum = seqNum;
         packet.payloadType = 126;
         seqNum++;
-        fb->InsertPacket(packet, VCMTickTime::MillisecondTimestamp(), false, 0);
+        fb->InsertPacket(packet, clock.MillisecondTimestamp(), false, 0);
         TEST(frameList.Insert(fb) == 0);
     }
     VCMFrameListItem* item = NULL;
@@ -135,7 +136,7 @@ int JitterBufferTest(CmdArgs& args)
 
     //printf("DONE timestamp ordered frame list\n");
 
-    VCMJitterBuffer jb;
+    VCMJitterBuffer jb(&clock);
 
     seqNum = 1234;
     timeStamp = 123*90;

src/modules/video_coding/main/test/jitter_estimate_test.cc

@@ -11,7 +11,6 @@
 #include <stdio.h>
 #include <ctime>
 #include "JitterEstimateTest.h"
-#include "tick_time.h"
 
 using namespace webrtc;
 

src/modules/video_coding/main/test/media_opt_test.cc

@@ -34,8 +34,9 @@ int MediaOptTest::RunTest(int testNum, CmdArgs& args)
     Trace::CreateTrace();
     Trace::SetTraceFile((test::OutputPath() + "mediaOptTestTrace.txt").c_str());
     Trace::SetLevelFilter(webrtc::kTraceAll);
-    VideoCodingModule* vcm = VideoCodingModule::Create(1);
+    TickTimeBase clock;
-    MediaOptTest* mot = new MediaOptTest(vcm);
+    VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
+    MediaOptTest* mot = new MediaOptTest(vcm, &clock);
     if (testNum == 0)
     { // regular
          mot->Setup(0, args);
@@ -66,8 +67,9 @@ int MediaOptTest::RunTest(int testNum, CmdArgs& args)
 }
 
 
-MediaOptTest::MediaOptTest(VideoCodingModule* vcm):
+MediaOptTest::MediaOptTest(VideoCodingModule* vcm, TickTimeBase* clock):
 _vcm(vcm),
+_clock(clock),
 _width(0),
 _height(0),
 _lengthSourceFrame(0),
@@ -279,7 +281,8 @@ MediaOptTest::Perform()
     encodeCompleteCallback->SetCodecType(ConvertCodecType(_codecName.c_str()));
     encodeCompleteCallback->SetFrameDimensions(_width, _height);
     // frame ready to be sent to network
-    RTPSendCompleteCallback* outgoingTransport = new RTPSendCompleteCallback(_rtp);
+    RTPSendCompleteCallback* outgoingTransport =
+        new RTPSendCompleteCallback(_rtp, _clock);
     _rtp->RegisterSendTransport(outgoingTransport);
     //FrameReceiveCallback
     VCMDecodeCompleteCallback receiveCallback(_decodedFile);

src/modules/video_coding/main/test/media_opt_test.h

@@ -31,7 +31,8 @@
 class MediaOptTest
 {
 public:
-    MediaOptTest(webrtc::VideoCodingModule* vcm);
+    MediaOptTest(webrtc::VideoCodingModule* vcm,
+                 webrtc::TickTimeBase* clock);
     ~MediaOptTest();
 
     static int RunTest(int testNum, CmdArgs& args);
@@ -51,6 +52,7 @@ private:
 
     webrtc::VideoCodingModule*       _vcm;
     webrtc::RtpRtcp*                 _rtp;
+    webrtc::TickTimeBase*            _clock;
     std::string                      _inname;
     std::string                      _outname;
     std::string                      _actualSourcename;

src/modules/video_coding/main/test/mt_rx_tx_test.cc

@@ -170,7 +170,8 @@ int MTRxTxTest(CmdArgs& args)
     TEST(rtp->SetGenericFECStatus(fecEnabled, VCM_RED_PAYLOAD_TYPE, VCM_ULPFEC_PAYLOAD_TYPE) == 0);
 
     //VCM
-    VideoCodingModule* vcm = VideoCodingModule::Create(1);
+    TickTimeBase clock;
+    VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
     if (vcm->InitializeReceiver() < 0)
     {
         return -1;
@@ -215,7 +216,8 @@ int MTRxTxTest(CmdArgs& args)
     encodeCompleteCallback->SetCodecType(ConvertCodecType(args.codecName.c_str()));
     encodeCompleteCallback->SetFrameDimensions(width, height);
     // frame ready to be sent to network
-    RTPSendCompleteCallback* outgoingTransport = new RTPSendCompleteCallback(rtp, "dump.rtp");
+    RTPSendCompleteCallback* outgoingTransport =
+        new RTPSendCompleteCallback(rtp, &clock, "dump.rtp");
     rtp->RegisterSendTransport(outgoingTransport);
     // FrameReceiveCallback
     VCMDecodeCompleteCallback receiveCallback(decodedFile);

src/modules/video_coding/main/test/mt_test_common.cc

@@ -12,13 +12,15 @@
 
 #include <cmath>
 
+#include "modules/video_coding/main/source/tick_time_base.h"
 #include "rtp_dump.h"
 
 namespace webrtc {
 
 TransportCallback::TransportCallback(webrtc::RtpRtcp* rtp,
+                                     TickTimeBase* clock,
                                      const char* filename):
-RTPSendCompleteCallback(rtp, filename)
+RTPSendCompleteCallback(rtp, clock, filename)
 {
     //
 }
@@ -49,7 +51,8 @@ TransportCallback::SendPacket(int channel, const void *data, int len)
         transmitPacket = PacketLoss();
     }
 
-    WebRtc_UWord64 now = VCMTickTime::MillisecondTimestamp();
+    TickTimeBase clock;
+    int64_t now = clock.MillisecondTimestamp();
     // Insert outgoing packet into list
     if (transmitPacket)
     {
@@ -73,7 +76,8 @@ TransportCallback::TransportPackets()
 {
     // Are we ready to send packets to the receiver?
     rtpPacket* packet = NULL;
-    WebRtc_UWord64 now = VCMTickTime::MillisecondTimestamp();
+    TickTimeBase clock;
+    int64_t now = clock.MillisecondTimestamp();
 
     while (!_rtpPackets.Empty())
     {

src/modules/video_coding/main/test/mt_test_common.h

@@ -47,15 +47,15 @@ class TransportCallback:public RTPSendCompleteCallback
 {
  public:
     // constructor input: (receive side) rtp module to send encoded data to
-    TransportCallback(webrtc::RtpRtcp* rtp,
+    TransportCallback(webrtc::RtpRtcp* rtp, TickTimeBase* clock,
                       const char* filename = NULL);
-     virtual ~TransportCallback();
+    virtual ~TransportCallback();
-     // Add packets to list
+    // Add packets to list
-     // Incorporate network conditions - delay and packet loss
+    // Incorporate network conditions - delay and packet loss
-     // Actual transmission will occur on a separate thread
+    // Actual transmission will occur on a separate thread
-     int SendPacket(int channel, const void *data, int len);
+    int SendPacket(int channel, const void *data, int len);
-     // Send to the receiver packets which are ready to be submitted
+    // Send to the receiver packets which are ready to be submitted
-     int TransportPackets();
+    int TransportPackets();
 };
 
 class SharedRTPState

src/modules/video_coding/main/test/normal_test.cc

@@ -17,10 +17,10 @@
 
 #include "../source/event.h"
 #include "common_types.h"
+#include "modules/video_coding/main/source/mock/fake_tick_time.h"
 #include "test_callbacks.h"
 #include "test_macros.h"
 #include "test_util.h"
-#include "tick_time.h"
 #include "trace.h"
 #include "testsupport/metrics/video_metrics.h"
 
@@ -28,18 +28,19 @@ using namespace webrtc;
 
 int NormalTest::RunTest(CmdArgs& args)
 {
-    // Don't run this test with debug time
+#if defined(EVENT_DEBUG)
-#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
     printf("SIMULATION TIME\n");
+    FakeTickTime clock(0);
 #else
     printf("REAL-TIME\n");
+    TickTimeBase clock;
 #endif
     Trace::CreateTrace();
     Trace::SetTraceFile(
         (test::OutputPath() + "VCMNormalTestTrace.txt").c_str());
     Trace::SetLevelFilter(webrtc::kTraceAll);
-    VideoCodingModule* vcm = VideoCodingModule::Create(1);
+    VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
-    NormalTest VCMNTest(vcm);
+    NormalTest VCMNTest(vcm, &clock);
     VCMNTest.Perform(args);
     VideoCodingModule::Destroy(vcm);
     Trace::ReturnTrace();
@@ -182,8 +183,9 @@ VCMNTDecodeCompleCallback::DecodedBytes()
 
  //VCM Normal Test Class implementation
 
-NormalTest::NormalTest(VideoCodingModule* vcm)
+NormalTest::NormalTest(VideoCodingModule* vcm, TickTimeBase* clock)
 :
+_clock(clock),
 _vcm(vcm),
 _sumEncBytes(0),
 _timeStamp(0),
@@ -281,8 +283,8 @@ NormalTest::Perform(CmdArgs& args)
 
     while (feof(_sourceFile) == 0)
     {
-#if !(defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG))
+#if !defined(EVENT_DEBUG)
-        WebRtc_Word64 processStartTime = VCMTickTime::MillisecondTimestamp();
+        WebRtc_Word64 processStartTime = _clock->MillisecondTimestamp();
 #endif
         TEST(fread(tmpBuffer, 1, _lengthSourceFrame, _sourceFile) > 0 ||
              feof(_sourceFile));
@@ -314,13 +316,10 @@ NormalTest::Perform(CmdArgs& args)
             _vcm->Process();
         }
         WebRtc_UWord32 framePeriod = static_cast<WebRtc_UWord32>(1000.0f/static_cast<float>(_sendCodec.maxFramerate) + 0.5f);
-#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
+#if defined(EVENT_DEBUG)
-        for (unsigned int i=0; i < framePeriod; i++)
+        static_cast<FakeTickTime*>(_clock)->IncrementDebugClock(framePeriod);
-        {
-            VCMTickTime::IncrementDebugClock();
-        }
 #else
-        WebRtc_Word64 timeSpent = VCMTickTime::MillisecondTimestamp() - processStartTime;
+        WebRtc_Word64 timeSpent = _clock->MillisecondTimestamp() - processStartTime;
         if (timeSpent < framePeriod)
         {
             waitEvent->Wait(framePeriod - timeSpent);

src/modules/video_coding/main/test/normal_test.h

@@ -83,7 +83,8 @@ private:
 class NormalTest
 {
 public:
-    NormalTest(webrtc::VideoCodingModule* vcm);
+    NormalTest(webrtc::VideoCodingModule* vcm,
+               webrtc::TickTimeBase* clock);
     ~NormalTest();
     static int RunTest(CmdArgs& args);
     WebRtc_Word32    Perform(CmdArgs& args);
@@ -105,6 +106,7 @@ protected:
     // calculating pipeline delay, and decoding time
     void            FrameDecoded(WebRtc_UWord32 timeStamp);
 
+    webrtc::TickTimeBase*            _clock;
     webrtc::VideoCodingModule*       _vcm;
     webrtc::VideoCodec               _sendCodec;
     webrtc::VideoCodec               _receiveCodec;

src/modules/video_coding/main/test/quality_modes_test.cc

@@ -15,6 +15,7 @@
 #include <time.h>
 
 #include "../source/event.h"
+#include "modules/video_coding/main/source/tick_time_base.h"
 #include "test_callbacks.h"
 #include "test_macros.h"
 #include "testsupport/metrics/video_metrics.h"
@@ -24,20 +25,22 @@ using namespace webrtc;
 
 int qualityModeTest()
 {
-    // Don't run this test with debug time
+    // Don't run this test with debug events.
-#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
+#if defined(EVENT_DEBUG)
     return -1;
 #endif
-    VideoCodingModule* vcm = VideoCodingModule::Create(1);
+    TickTimeBase clock;
-    QualityModesTest QMTest(vcm);
+    VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
+    QualityModesTest QMTest(vcm, &clock);
     QMTest.Perform();
     VideoCodingModule::Destroy(vcm);
     return 0;
 }
 
 
-QualityModesTest::QualityModesTest(VideoCodingModule *vcm):
+QualityModesTest::QualityModesTest(VideoCodingModule* vcm,
-NormalTest(vcm),
+                                   TickTimeBase* clock):
+NormalTest(vcm, clock),
 _vpm()
 {
     //

src/modules/video_coding/main/test/quality_modes_test.h

@@ -20,7 +20,8 @@ int qualityModeTest();
 class QualityModesTest : public NormalTest
 {
 public:
-    QualityModesTest(webrtc::VideoCodingModule* vcm);
+    QualityModesTest(webrtc::VideoCodingModule* vcm,
+                     webrtc::TickTimeBase* clock);
     virtual ~QualityModesTest();
     WebRtc_Word32 Perform();
 

src/modules/video_coding/main/test/receiver_timing_tests.cc

@@ -11,7 +11,6 @@
 #include "receiver_tests.h"
 #include "video_coding.h"
 #include "trace.h"
-#include "tick_time.h"
 #include "../source/event.h"
 #include "../source/internal_defines.h"
 #include "timing.h"
@@ -49,8 +48,8 @@ public:
 
 int ReceiverTimingTests(CmdArgs& args)
 {
-    // Make sure this test is never executed with simulated clocks
+    // Make sure this test is never executed with simulated events.
-#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
+#if defined(EVENT_DEBUG)
     return -1;
 #endif
 
@@ -62,7 +61,8 @@ int ReceiverTimingTests(CmdArgs& args)
     // A static random seed
     srand(0);
 
-    VCMTiming timing;
+    TickTimeBase clock;
+    VCMTiming timing(&clock);
     float clockInMs = 0.0;
     WebRtc_UWord32 waitTime = 0;
     WebRtc_UWord32 jitterDelayMs = 0;

src/modules/video_coding/main/test/rtp_player.cc

@@ -20,8 +20,8 @@
 
 #include "../source/internal_defines.h"
 #include "gtest/gtest.h"
+#include "modules/video_coding/main/source/tick_time_base.h"
 #include "rtp_rtcp.h"
-#include "tick_time.h"
 
 using namespace webrtc;
 
@@ -82,7 +82,9 @@ WebRtc_UWord32 LostPackets::AddPacket(WebRtc_UWord8* rtpData, WebRtc_UWord16 rtp
     return 0;
 }
 
-WebRtc_UWord32 LostPackets::SetResendTime(WebRtc_UWord16 sequenceNumber, WebRtc_Word64 resendTime)
+WebRtc_UWord32 LostPackets::SetResendTime(WebRtc_UWord16 sequenceNumber,
+                                          WebRtc_Word64 resendTime,
+                                          WebRtc_Word64 nowMs)
 {
     CriticalSectionScoped cs(_critSect);
     ListItem* item = First();
@@ -90,7 +92,6 @@ WebRtc_UWord32 LostPackets::SetResendTime(WebRtc_UWord16 sequenceNumber, WebRtc_
     {
         RawRtpPacket* packet = static_cast<RawRtpPacket*>(item->GetItem());
         const WebRtc_UWord16 seqNo = (packet->rtpData[2] << 8) + packet->rtpData[3];
-        const WebRtc_Word64 nowMs = VCMTickTime::MillisecondTimestamp();
         if (sequenceNumber == seqNo && packet->resendTimeMs + 10 < nowMs)
         {
             if (_debugFile != NULL)
@@ -123,18 +124,21 @@ WebRtc_UWord32 LostPackets::NumberOfPacketsToResend() const
     return count;
 }
 
-void LostPackets::ResentPacket(WebRtc_UWord16 seqNo)
+void LostPackets::ResentPacket(WebRtc_UWord16 seqNo, WebRtc_Word64 nowMs)
 {
     CriticalSectionScoped cs(_critSect);
     if (_debugFile != NULL)
     {
         fprintf(_debugFile, "Resent %u at %u\n", seqNo,
-                MaskWord64ToUWord32(VCMTickTime::MillisecondTimestamp()));
+                MaskWord64ToUWord32(nowMs));
     }
 }
 
-RTPPlayer::RTPPlayer(const char* filename, RtpData* callback)
+RTPPlayer::RTPPlayer(const char* filename,
+                     RtpData* callback,
+                     TickTimeBase* clock)
 :
+_clock(clock),
 _rtpModule(*RtpRtcp::CreateRtpRtcp(1, false)),
 _nextRtpTime(0),
 _dataCallback(callback),
@@ -272,7 +276,7 @@ WebRtc_Word32 RTPPlayer::ReadHeader()
 
 WebRtc_UWord32 RTPPlayer::TimeUntilNextPacket() const
 {
-    WebRtc_Word64 timeLeft = (_nextRtpTime - _firstPacketRtpTime) - (VCMTickTime::MillisecondTimestamp() - _firstPacketTimeMs);
+    WebRtc_Word64 timeLeft = (_nextRtpTime - _firstPacketRtpTime) - (_clock->MillisecondTimestamp() - _firstPacketTimeMs);
     if (timeLeft < 0)
     {
         return 0;
@@ -305,7 +309,8 @@ WebRtc_Word32 RTPPlayer::NextPacket(const WebRtc_Word64 timeNow)
             _resendPacketCount++;
             if (ret > 0)
             {
-                _lostPackets.ResentPacket(seqNo);
+                _lostPackets.ResentPacket(seqNo,
+                                          _clock->MillisecondTimestamp());
             }
             else if (ret < 0)
             {
@@ -327,7 +332,7 @@ WebRtc_Word32 RTPPlayer::NextPacket(const WebRtc_Word64 timeNow)
         if (_firstPacket)
         {
             _firstPacketRtpTime = static_cast<WebRtc_Word64>(_nextRtpTime);
-            _firstPacketTimeMs = VCMTickTime::MillisecondTimestamp();
+            _firstPacketTimeMs = _clock->MillisecondTimestamp();
         }
         if (_reordering && _reorderBuffer == NULL)
         {
@@ -447,7 +452,9 @@ WebRtc_Word32 RTPPlayer::ResendPackets(const WebRtc_UWord16* sequenceNumbers, We
     }
     for (int i=0; i < length; i++)
     {
-        _lostPackets.SetResendTime(sequenceNumbers[i], VCMTickTime::MillisecondTimestamp() + _rttMs);
+        _lostPackets.SetResendTime(sequenceNumbers[i],
+                                   _clock->MillisecondTimestamp() + _rttMs,
+                                   _clock->MillisecondTimestamp());
     }
     return 0;
 }

src/modules/video_coding/main/test/rtp_player.h

@@ -16,6 +16,7 @@
 #include "list_wrapper.h"
 #include "critical_section_wrapper.h"
 #include "video_coding_defines.h"
+#include "modules/video_coding/main/source/tick_time_base.h"
 
 #include <stdio.h>
 #include <string>
@@ -42,10 +43,12 @@ public:
     ~LostPackets();
 
     WebRtc_UWord32 AddPacket(WebRtc_UWord8* rtpData, WebRtc_UWord16 rtpLen);
-    WebRtc_UWord32 SetResendTime(WebRtc_UWord16 sequenceNumber, WebRtc_Word64 resendTime);
+    WebRtc_UWord32 SetResendTime(WebRtc_UWord16 sequenceNumber,
+                                 WebRtc_Word64 resendTime,
+                                 WebRtc_Word64 nowMs);
     WebRtc_UWord32 TotalNumberOfLosses() const { return _lossCount; };
     WebRtc_UWord32 NumberOfPacketsToResend() const;
-    void ResentPacket(WebRtc_UWord16 seqNo);
+    void ResentPacket(WebRtc_UWord16 seqNo, WebRtc_Word64 nowMs);
     void Lock()     {_critSect->Enter();};
     void Unlock()   {_critSect->Leave();};
 private:
@@ -66,7 +69,9 @@ struct PayloadCodecTuple
 class RTPPlayer : public webrtc::VCMPacketRequestCallback
 {
 public:
-    RTPPlayer(const char* filename, webrtc::RtpData* callback);
+    RTPPlayer(const char* filename,
+              webrtc::RtpData* callback,
+              webrtc::TickTimeBase* clock);
     virtual ~RTPPlayer();
 
     WebRtc_Word32 Initialize(const webrtc::ListWrapper& payloadList);
@@ -81,6 +86,7 @@ private:
     WebRtc_Word32 SendPacket(WebRtc_UWord8* rtpData, WebRtc_UWord16 rtpLen);
     WebRtc_Word32 ReadPacket(WebRtc_Word16* rtpdata, WebRtc_UWord32* offset);
     WebRtc_Word32 ReadHeader();
+    webrtc::TickTimeBase* _clock;
     FILE*              _rtpFile;
     webrtc::RtpRtcp&   _rtpModule;
     WebRtc_UWord32     _nextRtpTime;

src/modules/video_coding/main/test/test_callbacks.cc

@@ -12,6 +12,7 @@
 
 #include <cmath>
 
+#include "modules/video_coding/main/source/tick_time_base.h"
 #include "rtp_dump.h"
 #include "test_macros.h"
 
@@ -199,7 +200,9 @@ VCMDecodeCompleteCallback::DecodedBytes()
 }
 
 RTPSendCompleteCallback::RTPSendCompleteCallback(RtpRtcp* rtp,
+                                                 TickTimeBase* clock,
                                                  const char* filename):
+    _clock(clock),
     _sendCount(0),
     _rtp(rtp),
     _lossPct(0),
@@ -251,7 +254,7 @@ RTPSendCompleteCallback::SendPacket(int channel, const void *data, int len)
     bool transmitPacket = true;
     transmitPacket = PacketLoss();
 
-    WebRtc_UWord64 now = VCMTickTime::MillisecondTimestamp();
+    WebRtc_UWord64 now = _clock->MillisecondTimestamp();
     // Insert outgoing packet into list
     if (transmitPacket)
     {

src/modules/video_coding/main/test/test_callbacks.h

@@ -24,7 +24,6 @@
 #include "module_common_types.h"
 #include "rtp_rtcp.h"
 #include "test_util.h"
-#include "tick_time.h"
 #include "trace.h"
 #include "video_coding.h"
 
@@ -157,7 +156,7 @@ class RTPSendCompleteCallback: public Transport
 {
 public:
     // Constructor input: (receive side) rtp module to send encoded data to
-    RTPSendCompleteCallback(RtpRtcp* rtp,
+    RTPSendCompleteCallback(RtpRtcp* rtp, TickTimeBase* clock,
                             const char* filename = NULL);
     virtual ~RTPSendCompleteCallback();
     // Send Packet to receive side RTP module
@@ -184,6 +183,7 @@ protected:
     // Random uniform loss model
     bool UnifomLoss(double lossPct);
 
+    TickTimeBase*           _clock;
     WebRtc_UWord32          _sendCount;
     RtpRtcp*                _rtp;
     double                  _lossPct;

src/modules/video_coding/main/test/tester_main.cc

@@ -27,16 +27,10 @@
 using namespace webrtc;
 
 /*
- * Build with TICK_TIME_DEBUG and EVENT_DEBUG defined
+ * Build with EVENT_DEBUG defined
- * to build the tests with simulated clock.
+ * to build the tests with simulated events.
  */
 
-// TODO(holmer): How do we get debug time into the cmd line interface?
-/* Debug time */
-#if defined(TICK_TIME_DEBUG) && defined(EVENT_DEBUG)
-WebRtc_Word64 VCMTickTime::_timeNowDebug = 0; // current time in ms
-#endif
-
 int vcmMacrosTests = 0;
 int vcmMacrosErrors = 0;
 

src/modules/video_coding/main/test/video_rtp_play.cc

@@ -12,11 +12,11 @@
 #include "video_coding.h"
 #include "rtp_rtcp.h"
 #include "trace.h"
-#include "tick_time.h"
 #include "../source/event.h"
 #include "../source/internal_defines.h"
 #include "test_macros.h"
 #include "rtp_player.h"
+#include "modules/video_coding/main/source/mock/fake_tick_time.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -72,8 +72,8 @@ FrameReceiveCallback::FrameToRender(VideoFrame& videoFrame)
 
 int RtpPlay(CmdArgs& args)
 {
-    // Make sure this test isn't executed without simulated clocks
+    // Make sure this test isn't executed without simulated events.
-#if !defined(TICK_TIME_DEBUG) || !defined(EVENT_DEBUG)
+#if !defined(EVENT_DEBUG)
     return -1;
 #endif
     // BEGIN Settings
@@ -90,9 +90,10 @@ int RtpPlay(CmdArgs& args)
     if (outFile == "")
         outFile = test::OutputPath() + "RtpPlay_decoded.yuv";
     FrameReceiveCallback receiveCallback(outFile);
-    VideoCodingModule* vcm = VideoCodingModule::Create(1);
+    FakeTickTime clock(0);
+    VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
     RtpDataCallback dataCallback(vcm);
-    RTPPlayer rtpStream(args.inputFile.c_str(), &dataCallback);
+    RTPPlayer rtpStream(args.inputFile.c_str(), &dataCallback, &clock);
 
 
     ListWrapper payloadTypes;
@@ -150,9 +151,9 @@ int RtpPlay(CmdArgs& args)
     ret = 0;
 
     // RTP stream main loop
-    while ((ret = rtpStream.NextPacket(VCMTickTime::MillisecondTimestamp())) == 0)
+    while ((ret = rtpStream.NextPacket(clock.MillisecondTimestamp())) == 0)
     {
-        if (VCMTickTime::MillisecondTimestamp() % 5 == 0)
+        if (clock.MillisecondTimestamp() % 5 == 0)
         {
             ret = vcm->Decode();
             if (ret < 0)
@@ -165,11 +166,11 @@ int RtpPlay(CmdArgs& args)
         {
             vcm->Process();
         }
-        if (MAX_RUNTIME_MS > -1 && VCMTickTime::MillisecondTimestamp() >= MAX_RUNTIME_MS)
+        if (MAX_RUNTIME_MS > -1 && clock.MillisecondTimestamp() >= MAX_RUNTIME_MS)
         {
             break;
         }
-        VCMTickTime::IncrementDebugClock();
+        clock.IncrementDebugClock(1);
     }
 
     switch (ret)

src/modules/video_coding/main/test/video_rtp_play_mt.cc

@@ -14,7 +14,6 @@
 #include "trace.h"
 #include "thread_wrapper.h"
 #include "../source/event.h"
-#include "tick_time.h"
 #include "test_macros.h"
 #include "rtp_player.h"
 
@@ -40,8 +39,8 @@ bool RtpReaderThread(void* obj)
     SharedState* state = static_cast<SharedState*>(obj);
     EventWrapper& waitEvent = *EventWrapper::Create();
     // RTP stream main loop
-    WebRtc_Word64 nowMs = VCMTickTime::MillisecondTimestamp();
+    TickTimeBase clock;
-    if (state->_rtpPlayer.NextPacket(nowMs) < 0)
+    if (state->_rtpPlayer.NextPacket(clock.MillisecondTimestamp()) < 0)
     {
         return false;
     }
@@ -60,8 +59,8 @@ bool DecodeThread(void* obj)
 
 int RtpPlayMT(CmdArgs& args, int releaseTestNo, webrtc::VideoCodecType releaseTestVideoType)
 {
-    // Don't run these tests with debug time
+    // Don't run these tests with debug events.
-#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
+#if defined(EVENT_DEBUG)
     return -1;
 #endif
 
@@ -82,8 +81,9 @@ int RtpPlayMT(CmdArgs& args, int releaseTestNo, webrtc::VideoCodecType releaseTe
                 (protection == kProtectionDualDecoder ||
                 protection == kProtectionNack ||
                 kProtectionNackFEC));
+    TickTimeBase clock;
     VideoCodingModule* vcm =
-            VideoCodingModule::Create(1);
+            VideoCodingModule::Create(1, &clock);
     RtpDataCallback dataCallback(vcm);
     std::string rtpFilename;
     rtpFilename = args.inputFile;
@@ -136,7 +136,7 @@ int RtpPlayMT(CmdArgs& args, int releaseTestNo, webrtc::VideoCodecType releaseTe
         }
         printf("Watch %s to verify that the output is reasonable\n", outFilename.c_str());
     }
-    RTPPlayer rtpStream(rtpFilename.c_str(), &dataCallback);
+    RTPPlayer rtpStream(rtpFilename.c_str(), &dataCallback, &clock);
     ListWrapper payloadTypes;
     payloadTypes.PushFront(new PayloadCodecTuple(VCM_VP8_PAYLOAD_TYPE,
                                                  "VP8", kVideoCodecVP8));