Add thread-checking to TransportFeedbackAdapter

webrtc/modules/congestion_controller/transport_feedback_adapter.cc

 /*
  *  Copyright (c) 2015 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 36 matching lines @@
     BitrateController* bitrate_controller)
     : send_side_bwe_with_overhead_(webrtc::field_trial::FindFullName(
                                        "WebRTC-SendSideBwe-WithOverhead") ==
                                    "Enabled"),
       transport_overhead_bytes_per_packet_(0),
       send_time_history_(clock, kSendTimeHistoryWindowMs),
       event_log_(event_log),
       clock_(clock),
       current_offset_ms_(kNoTimestamp),
       last_timestamp_us_(kNoTimestamp),
-      bitrate_controller_(bitrate_controller) {}
+      bitrate_controller_(bitrate_controller) {
+  packetizer_thread_checker_.DetachFromThread();
+  module_process_thread_checker_.DetachFromThread();
+}
 
-TransportFeedbackAdapter::~TransportFeedbackAdapter() {}
+TransportFeedbackAdapter::~TransportFeedbackAdapter() {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+}
 
 void TransportFeedbackAdapter::InitBwe() {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   rtc::CritScope cs(&bwe_lock_);
   delay_based_bwe_.reset(new DelayBasedBwe(event_log_, clock_));
 }
 
 void TransportFeedbackAdapter::AddPacket(uint16_t sequence_number,
                                          size_t length,
                                          const PacedPacketInfo& pacing_info) {
+  RTC_DCHECK(packetizer_thread_checker_.CalledOnValidThread());

[stefan-webrtc, 2017/02/24 14:48:53]

Maybe the value of this is small? WDYT?

[elad.alon_webrtc.org, 2017/02/27 10:55:30]

Hard for me to say. It does make sure no one ever tries to call this function
from two different threads, but that does seem unlikely. Could be argued it
would be nice to have this here for symmetry's sake. Also, we could check this
isn't called on the other threads (make sure the threads are distinct, which we
don't do now). Or remove completely. Which do you prefer?

   rtc::CritScope cs(&lock_);
   if (send_side_bwe_with_overhead_) {
     length += transport_overhead_bytes_per_packet_;
   }
   send_time_history_.AddAndRemoveOld(sequence_number, length, pacing_info);
 }
 
 void TransportFeedbackAdapter::OnSentPacket(uint16_t sequence_number,
                                             int64_t send_time_ms) {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   rtc::CritScope cs(&lock_);
   send_time_history_.OnSentPacket(sequence_number, send_time_ms);
 }
 
 void TransportFeedbackAdapter::SetStartBitrate(int start_bitrate_bps) {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   rtc::CritScope cs(&bwe_lock_);
   delay_based_bwe_->SetStartBitrate(start_bitrate_bps);
 }
 
 void TransportFeedbackAdapter::SetMinBitrate(int min_bitrate_bps) {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   rtc::CritScope cs(&bwe_lock_);
   delay_based_bwe_->SetMinBitrate(min_bitrate_bps);
 }
 
 void TransportFeedbackAdapter::SetTransportOverhead(
     int transport_overhead_bytes_per_packet) {
   rtc::CritScope cs(&lock_);
   transport_overhead_bytes_per_packet_ = transport_overhead_bytes_per_packet;
 }
 
 int64_t TransportFeedbackAdapter::GetProbingIntervalMs() const {
   rtc::CritScope cs(&bwe_lock_);
   return delay_based_bwe_->GetProbingIntervalMs();
 }
 
 std::vector<PacketInfo> TransportFeedbackAdapter::GetPacketFeedbackVector(
     const rtcp::TransportFeedback& feedback) {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   int64_t timestamp_us = feedback.GetBaseTimeUs();
   // Add timestamp deltas to a local time base selected on first packet arrival.
   // This won't be the true time base, but makes it easier to manually inspect
   // time stamps.
   if (last_timestamp_us_ == kNoTimestamp) {
     current_offset_ms_ = clock_->TimeInMilliseconds();
   } else {
     int64_t delta = timestamp_us - last_timestamp_us_;
 
     // Detect and compensate for wrap-arounds in base time.
@@ skipping 33 matching lines @@
       LOG(LS_WARNING) << "Failed to lookup send time for " << failed_lookups
                       << " packet" << (failed_lookups > 1 ? "s" : "")
                       << ". Send time history too small?";
     }
   }
   return packet_feedback_vector;
 }
 
 void TransportFeedbackAdapter::OnTransportFeedback(
     const rtcp::TransportFeedback& feedback) {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   last_packet_feedback_vector_ = GetPacketFeedbackVector(feedback);
   DelayBasedBwe::Result result;
   {
     rtc::CritScope cs(&bwe_lock_);
     result = delay_based_bwe_->IncomingPacketFeedbackVector(
         last_packet_feedback_vector_);
   }
   if (result.updated)
     bitrate_controller_->OnDelayBasedBweResult(result);
 }
 
 std::vector<PacketInfo> TransportFeedbackAdapter::GetTransportFeedbackVector()
     const {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return last_packet_feedback_vector_;
 }
 
 void TransportFeedbackAdapter::OnRttUpdate(int64_t avg_rtt_ms,
                                            int64_t max_rtt_ms) {
+  RTC_DCHECK(module_process_thread_checker_.CalledOnValidThread());
   rtc::CritScope cs(&bwe_lock_);
   delay_based_bwe_->OnRttUpdate(avg_rtt_ms, max_rtt_ms);
 }
 
 }  // namespace webrtc