Temporary hack to avoid assert errors when time moves backwards.

webrtc/modules/pacing/paced_sender.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.
  */
 
@@ skipping 17 matching lines @@
 
 // Upper cap on process interval, in case process has not been called in a long
 // time.
 const int64_t kMaxIntervalTimeMs = 30;
 
 }  // namespace
 
 // TODO(sprang): Move at least PacketQueue and MediaBudget out to separate
 // files, so that we can more easily test them.
 
+// Note about the -1 enqueue times below:
+// This is a temporary hack to avoid crashes when the real-time clock is
+// adjusted backwards, which can happen on Android when the phone syncs the
+// clock to the network. See this bug:
+// https://bugs.chromium.org/p/webrtc/issues/detail?id=5452
+// We can't just comment out the DCHECK either, as that would lead to the sum
+// being wrong. Instead we just ignore packets from the past when we calculate
+// the average queue time.
+
 namespace webrtc {
 namespace paced_sender {
 struct Packet {
   Packet(RtpPacketSender::Priority priority,
          uint32_t ssrc,
          uint16_t seq_number,
          int64_t capture_time_ms,
          int64_t enqueue_time_ms,
          size_t length_in_bytes,
          bool retransmission,
          uint64_t enqueue_order)
       : priority(priority),
         ssrc(ssrc),
         sequence_number(seq_number),
         capture_time_ms(capture_time_ms),
-        enqueue_time_ms(enqueue_time_ms),
+        // TODO(sprang): Remove -1 option once we can guarantee monotonic clock.
+        enqueue_time_ms(enqueue_time_ms),  // -1 = not valid; don't count.
         bytes(length_in_bytes),
         retransmission(retransmission),
         enqueue_order(enqueue_order) {}
 
   RtpPacketSender::Priority priority;
   uint32_t ssrc;
   uint16_t sequence_number;
   int64_t capture_time_ms;
   int64_t enqueue_time_ms;
   size_t bytes;
@@ skipping 28 matching lines @@
       : bytes_(0),
         clock_(clock),
         queue_time_sum_(0),
         time_last_updated_(clock_->TimeInMilliseconds()) {}
   virtual ~PacketQueue() {}
 
   void Push(const Packet& packet) {
     if (!AddToDupeSet(packet))
       return;
 
-    UpdateQueueTime(packet.enqueue_time_ms);
+    if (packet.enqueue_time_ms >= time_last_updated_)
+      UpdateQueueTime(packet.enqueue_time_ms);
 
     // Store packet in list, use pointers in priority queue for cheaper moves.
     // Packets have a handle to its own iterator in the list, for easy removal
     // when popping from queue.
     packet_list_.push_front(packet);
     std::list<Packet>::iterator it = packet_list_.begin();
+    if (packet.enqueue_time_ms < time_last_updated_)
+      it->enqueue_time_ms = -1;
     it->this_it = it;          // Handle for direct removal from list.
     prio_queue_.push(&(*it));  // Pointer into list.
     bytes_ += packet.bytes;
   }
 
   const Packet& BeginPop() {
     const Packet& packet = *prio_queue_.top();
     prio_queue_.pop();
     return packet;
   }
 
   void CancelPop(const Packet& packet) { prio_queue_.push(&(*packet.this_it)); }
 
   void FinalizePop(const Packet& packet) {
     RemoveFromDupeSet(packet);
     bytes_ -= packet.bytes;
-    queue_time_sum_ -= (time_last_updated_ - packet.enqueue_time_ms);
+    if (packet.enqueue_time_ms != -1)
+      queue_time_sum_ -= (time_last_updated_ - packet.enqueue_time_ms);
     packet_list_.erase(packet.this_it);
     RTC_DCHECK_EQ(packet_list_.size(), prio_queue_.size());
     if (packet_list_.empty())
       RTC_DCHECK_EQ(0u, queue_time_sum_);
   }
 
   bool Empty() const { return prio_queue_.empty(); }
 
   size_t SizeInPackets() const { return prio_queue_.size(); }
 
   uint64_t SizeInBytes() const { return bytes_; }
 
   int64_t OldestEnqueueTimeMs() const {
-    auto it = packet_list_.rbegin();
-    if (it == packet_list_.rend())
-      return 0;
-    return it->enqueue_time_ms;
+    for (auto it = packet_list_.rbegin(); it != packet_list_.rend(); ++it) {
+      if (it->enqueue_time_ms != -1)
+        return it->enqueue_time_ms;
+    }
+    return 0;
   }
 
   void UpdateQueueTime(int64_t timestamp_ms) {
-    RTC_DCHECK_GE(timestamp_ms, time_last_updated_);
+    // TODO(sprang): Remove this condition and reinstate a DCHECK once we have
+    // made sure all clocks are monotonic.
+    if (timestamp_ms < time_last_updated_)
+      return;
     int64_t delta = timestamp_ms - time_last_updated_;
     // Use packet packet_list_.size() not prio_queue_.size() here, as there
     // might be an outstanding element popped from prio_queue_ currently in the
     // SendPacket() call, while packet_list_ will always be correct.
     queue_time_sum_ += delta * packet_list_.size();
     time_last_updated_ = timestamp_ms;
   }
 
   int64_t AverageQueueTimeMs() const {
     if (prio_queue_.empty())
@@ skipping 295 matching lines @@
     media_budget_->UseBudget(bytes_sent);
     padding_budget_->UseBudget(bytes_sent);
   }
 }
 
 void PacedSender::UpdateBytesPerInterval(int64_t delta_time_ms) {
   media_budget_->IncreaseBudget(delta_time_ms);
   padding_budget_->IncreaseBudget(delta_time_ms);
 }
 }  // namespace webrtc