Improvements in how WebRTC.Audio.RecordedOnlyZeros is added as histogram

webrtc/modules/audio_device/audio_device_buffer.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 12 matching lines @@
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 
 static const char kTimerQueueName[] = "AudioDeviceBufferTimer";
 
 // Time between two sucessive calls to LogStats().
 static const size_t kTimerIntervalInSeconds = 10;
 static const size_t kTimerIntervalInMilliseconds =
     kTimerIntervalInSeconds * rtc::kNumMillisecsPerSec;
+// Min time required to qualify an audio session as a "call". If playout or
+// recording has been active for less than this time we will not store any
+// logs or UMA stats but instead consider the call as too short.
+static const size_t kMinValidCallTimeTimeInSeconds = 10;
+static const size_t kMinValidCallTimeTimeInMilliseconds =
+    kMinValidCallTimeTimeInSeconds * rtc::kNumMillisecsPerSec;
 
 AudioDeviceBuffer::AudioDeviceBuffer()
     : audio_transport_cb_(nullptr),
-      task_queue_(kTimerQueueName),
-      timer_has_started_(false),
+      playing_(false),
+      recording_(false),
       rec_sample_rate_(0),
       play_sample_rate_(0),
       rec_channels_(0),
       play_channels_(0),
       rec_bytes_per_sample_(0),
       play_bytes_per_sample_(0),
       current_mic_level_(0),
       new_mic_level_(0),
       typing_status_(false),
       play_delay_ms_(0),
       rec_delay_ms_(0),
       clock_drift_(0),
       num_stat_reports_(0),
       rec_callbacks_(0),
       last_rec_callbacks_(0),
       play_callbacks_(0),
       last_play_callbacks_(0),
       rec_samples_(0),
       last_rec_samples_(0),
       play_samples_(0),
       last_play_samples_(0),
       last_log_stat_time_(0),
       max_rec_level_(0),
       max_play_level_(0),
-      num_rec_level_is_zero_(0),
       rec_stat_count_(0),
-      play_stat_count_(0) {
+      play_stat_count_(0),
+      play_start_time_(0),
+      rec_start_time_(0),
+      only_silence_recorded_(true) {
   LOG(INFO) << "AudioDeviceBuffer::ctor";
 }
 
 AudioDeviceBuffer::~AudioDeviceBuffer() {

[tommi, 2016/10/25 16:43:22]

add checks for !playing_ and !recording_?

[henrika_webrtc, 2016/10/26 12:42:41]

Done.

   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(INFO) << "AudioDeviceBuffer::~dtor";
-
-  size_t total_diff_time = 0;
-  int num_measurements = 0;
-  LOG(INFO) << "[playout diff time => #measurements]";
-  for (size_t diff = 0; diff < arraysize(playout_diff_times_); ++diff) {
-    uint32_t num_elements = playout_diff_times_[diff];
-    if (num_elements > 0) {
-      total_diff_time += num_elements * diff;
-      num_measurements += num_elements;
-      LOG(INFO) << "[" << diff << " => " << num_elements << "]";
-    }
-  }
-  if (num_measurements > 0) {
-    LOG(INFO) << "total_diff_time: " << total_diff_time;
-    LOG(INFO) << "num_measurements: " << num_measurements;
-    LOG(INFO) << "average: "
-             << static_cast<float>(total_diff_time) / num_measurements;
-  }
-
-  // Add UMA histogram to keep track of the case when only zeros have been
-  // recorded. Ensure that recording callbacks have started and that at least
-  // one timer event has been able to update |num_rec_level_is_zero_|.
-  // I am avoiding use of the task queue here since we are under destruction
-  // and reading these members on the creating thread feels safe.
-  if (rec_callbacks_ > 0 && num_stat_reports_ > 0) {
-    RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.RecordedOnlyZeros",
-    static_cast<int>(num_stat_reports_ == num_rec_level_is_zero_));
-  }
 }
 
 int32_t AudioDeviceBuffer::RegisterAudioCallback(
     AudioTransport* audio_callback) {
   LOG(INFO) << __FUNCTION__;
   rtc::CritScope lock(&lock_cb_);
   audio_transport_cb_ = audio_callback;

[tommi, 2016/10/25 16:43:22]

first:
RTC_DCHECK(!audio_transport_cb_ || !audio_callback);

[tommi, 2016/10/25 16:43:22]

is it allowed to call RegisterAudioCallback while the callback is active?

[henrika_webrtc, 2016/10/26 12:42:41]

We actually have unit tests today for the ADM (which owns this class)
that uses nullptr as input here do deregister. See next comment as well.

[henrika_webrtc, 2016/10/26 12:42:41]

Long story since this API goes way back when the idea that all APIs should be as
flexible as possible. Today, we support starting media without any callback
registered. The native layer will still run but no "connection" to WebRTC exists
(all will be silent but audio is active in the background). Not used by any
client AFAIK and no unit test exists to force it.

I have https://bugs.chromium.org/p/webrtc/issues/detail?id=6560 where my plan is
to improve more in this class. If you don't mind, could we postpone some parts
from this CL to ensure that it does not change too much? I will then come back
and make more changes inline with this proposal.

   return 0;
 }
 
 int32_t AudioDeviceBuffer::InitPlayout() {

[tommi, 2016/10/25 16:43:22]

can we remove this function?

[henrika_webrtc, 2016/10/26 12:42:41]

Done.

   LOG(INFO) << __FUNCTION__;
+  return 0;
+}
+
+void AudioDeviceBuffer::StartPlayout() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  if (playing_) {

[tommi, 2016/10/25 16:43:23]

what about RTC_DCHECK(!playing_) ?

[henrika_webrtc, 2016/10/26 12:42:41]

Done.

+    return;
+  }
+  LOG(INFO) << __FUNCTION__;
   ResetPlayStats();
-  if (!timer_has_started_) {
+  // Start a periodic timer based on task queue if not already done by the
+  // recording side.
+  if (!task_queue_) {
     StartTimer();

[tommi, 2016/10/25 16:43:23]

it looks like every time StartTimer is called, you first check if task_queue_ is
not null.  What about moving this check into StartTimer and don't do anything if
task_queue_ is already valid?

[henrika_webrtc, 2016/10/26 12:42:40]

Excellent idea ;-)

-    timer_has_started_ = true;
   }
-  return 0;
+  playing_ = true;
 }
 
 int32_t AudioDeviceBuffer::InitRecording() {
   LOG(INFO) << __FUNCTION__;
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  ResetRecStats();
-  if (!timer_has_started_) {
-    StartTimer();
-    timer_has_started_ = true;
-  }
   return 0;
 }
 
+void AudioDeviceBuffer::StartRecording() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  if (recording_) {

[tommi, 2016/10/25 16:43:22]

RTC_DCHECK(!recording_)?

[henrika_webrtc, 2016/10/26 12:42:41]

Done.

+    return;
+  }
+  LOG(INFO) << __FUNCTION__;
+  ResetRecStats();
+  // Start a periodic timer based on task queue if not already done by the
+  // playout side.
+  if (!task_queue_) {
+    StartTimer();
+  }
+  recording_ = true;
+}
+
+void AudioDeviceBuffer::StopPlayout() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  if (!playing_) {

[tommi, 2016/10/25 16:43:22]

RTC_DCHECK(playing_) ?

[henrika_webrtc, 2016/10/26 12:42:41]

Done.

+    return;
+  }
+  LOG(INFO) << __FUNCTION__;
+  playing_ = false;
+  // Stop the timer if no more media is active.
+  if (!recording_) {
+    StopTimer();
+  }
+  // Add diagnostic logging of delta times for playout callbacks. We are doing
+  // this wihout a lock since playout should be stopped by now and it a minor
+  // conflict during stop will not have a great impact on the total statistics.
+  const size_t time_since_start = rtc::TimeSince(play_start_time_);
+  if (time_since_start > kMinValidCallTimeTimeInMilliseconds) {
+    size_t total_diff_time = 0;
+    int num_measurements = 0;
+    LOG(INFO) << "[playout diff time => #measurements]";
+    for (size_t diff = 0; diff < arraysize(playout_diff_times_); ++diff) {
+      uint32_t num_elements = playout_diff_times_[diff];
+      if (num_elements > 0) {
+        total_diff_time += num_elements * diff;
+        num_measurements += num_elements;
+        LOG(INFO) << "[" << diff << " => " << num_elements << "]";
+      }
+    }
+    if (num_measurements > 0) {
+      LOG(INFO) << "total_diff_time: " << total_diff_time;

[tommi, 2016/10/25 16:43:22]

can all of these be merged to one LOG statement?

I wonder what the difference would be for this .obj file in terms of size if
LOG(INFO) was made to be a no-op in release builds.  Seems like a lot of debug
logging that's not useful unless someone's actually debugging.

[henrika_webrtc, 2016/10/26 12:42:41]

Done.

+      LOG(INFO) << "num_measurements: " << num_measurements;
+      LOG(INFO) << "average: "
+               << static_cast<float>(total_diff_time) / num_measurements;
+    }
+  }
+  LOG(INFO) << "total playout time: " << time_since_start;
+}
+
+void AudioDeviceBuffer::StopRecording() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  if (!recording_) {

[tommi, 2016/10/25 16:43:22]

RTC_DCHECK(recording_) ?

[henrika_webrtc, 2016/10/26 12:42:41]

Done.

+    return;
+  }
+  LOG(INFO) << __FUNCTION__;
+  recording_ = false;
+  // Stop the timer if no more media is active.
+  if (!playing_) {
+    StopTimer();
+  }
+  // Add UMA histogram to keep track of the case when only zeros have been
+  // recorded. Measurements (max of absolute level) are taken twice per second,
+  // which means that if e.g 10 seconds of audio has been recorded, a total of
+  // 20 level estimates must all be identical to zero to trigger the histogram.
+  // |only_silence_recorded_| can only be cleared on the native audio thread
+  // that drives audio capture but we know by design that the audio has stopped
+  // when this method is called, hence there should not be aby conflicts. Also,
+  // the fact that |only_silence_recorded_| can be affected during the complete
+  // call makes chances of conflicts with potentially one last callback very
+  // small.
+  const size_t time_since_start = rtc::TimeSince(rec_start_time_);
+  if (time_since_start > kMinValidCallTimeTimeInMilliseconds) {
+    const int only_zeros = static_cast<int>(only_silence_recorded_);
+    RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.RecordedOnlyZeros", only_zeros);
+    LOG(INFO)  << "HISTOGRAM(WebRTC.Audio.RecordedOnlyZeros): " <<  only_zeros;

[tommi, 2016/10/25 16:43:22]

fix spaces

[henrika_webrtc, 2016/10/26 12:42:41]

Done.

+  }
+  LOG(INFO) << "total recording time: " << time_since_start;
+}
+
 int32_t AudioDeviceBuffer::SetRecordingSampleRate(uint32_t fsHz) {
   LOG(INFO) << "SetRecordingSampleRate(" << fsHz << ")";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   rec_sample_rate_ = fsHz;
   return 0;
 }
 
 int32_t AudioDeviceBuffer::SetPlayoutSampleRate(uint32_t fsHz) {
   LOG(INFO) << "SetPlayoutSampleRate(" << fsHz << ")";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   play_sample_rate_ = fsHz;
   return 0;
 }
 
 int32_t AudioDeviceBuffer::RecordingSampleRate() const {
   return rec_sample_rate_;
 }
 
 int32_t AudioDeviceBuffer::PlayoutSampleRate() const {
   return play_sample_rate_;
 }
 
 int32_t AudioDeviceBuffer::SetRecordingChannels(size_t channels) {

[tommi, 2016/10/25 16:43:22]

See also question elsewhere about the rec_channels lambda.

Can we restrict when this method is allowed to be called?  Specifically, is it
possible that we can make it so that calling this method is only allowed when
*not* recording?  If so, then we don't need a lock for rec_channels_ or
rec_bytes_per_sample_.

[henrika_webrtc, 2016/10/26 12:42:41]

I am working on a related CL which will improve how locks are handled in this
class. Adding restrictions can be tricky since changes on the fly can sometimes
be required when e.g. devices are plugged in and out.

   LOG(INFO) << "SetRecordingChannels(" << channels << ")";
   rtc::CritScope lock(&lock_);
   rec_channels_ = channels;
   rec_bytes_per_sample_ = sizeof(int16_t) * channels;
   return 0;
 }
 
 int32_t AudioDeviceBuffer::SetPlayoutChannels(size_t channels) {
   LOG(INFO) << "SetPlayoutChannels(" << channels << ")";
   rtc::CritScope lock(&lock_);
@@ skipping 67 matching lines @@
 
 int32_t AudioDeviceBuffer::StopOutputFileRecording() {
   LOG(LS_WARNING) << "Not implemented";
   return 0;
 }
 
 int32_t AudioDeviceBuffer::SetRecordedBuffer(const void* audio_buffer,
                                              size_t num_samples) {
   const size_t rec_channels = [&] {
     rtc::CritScope lock(&lock_);
     return rec_channels_;

[tommi, 2016/10/25 16:43:22]

why do we do this?  It looks like we're grabbing the lock twice inside this
function and might get two different values.  Wouldn't it be better to simply
fetch the value once and use the fetched value in both places?

[henrika_webrtc, 2016/10/26 12:42:41]

I use the lambda based on feedback from kwiberg@ in an earlier CL. I only take
it once in this method and the idea was to avoid an empty declaration only.

   }();
   // Copy the complete input buffer to the local buffer.
   const size_t size_in_bytes = num_samples * rec_channels * sizeof(int16_t);
   const size_t old_size = rec_buffer_.size();
   rec_buffer_.SetData(static_cast<const uint8_t*>(audio_buffer), size_in_bytes);
   // Keep track of the size of the recording buffer. Only updated when the
   // size changes, which is a rare event.
   if (old_size != rec_buffer_.size()) {
     LOG(LS_INFO) << "Size of recording buffer: " << rec_buffer_.size();

[tommi, 2016/10/25 16:43:23]

fyi - logging from within performance sensitive callbacks can be expensive. 
Amongst other things, it will grab a global lock for stdio, which means that
this can contend with any other thread that is logging or writing to stdout. 
Additionally it grabs the global g_log_crit lock, which is held while any
potential log sink's OnLogMessage method is called.

[henrika_webrtc, 2016/10/26 12:42:41]

Wow, didn't know that. It is a very, very rare event and only happens the first
time we set the size or if e.g. the sample rate of a device changes. 

May I keep it?

   }
-  // Derive a new level value twice per second.
+  // Derive a new level value twice per second and check if it is non-zero.
   int16_t max_abs = 0;
   RTC_DCHECK_LT(rec_stat_count_, 50);
   if (++rec_stat_count_ >= 50) {
     const size_t size = num_samples * rec_channels;
     // Returns the largest absolute value in a signed 16-bit vector.
     max_abs = WebRtcSpl_MaxAbsValueW16(
         reinterpret_cast<const int16_t*>(rec_buffer_.data()), size);
     rec_stat_count_ = 0;
+    // Set |only_silence_recorded_| to false as soon as at least one detection
+    // of a non-zero audio packet is found. It can only be restored to true
+    // again by restarting the call.
+    if (max_abs > 0) {
+      only_silence_recorded_ = false;
+    }
   }
   // Update some stats but do it on the task queue to ensure that the members
   // are modified and read on the same thread. Note that |max_abs| will be
   // zero in most calls and then have no effect of the stats. It is only updated
   // approximately two times per second and can then change the stats.
-  task_queue_.PostTask(rtc::Bind(&AudioDeviceBuffer::UpdateRecStats, this,
+  task_queue_->PostTask(rtc::Bind(&AudioDeviceBuffer::UpdateRecStats, this,
                                  max_abs, num_samples));
   return 0;
 }
 
 int32_t AudioDeviceBuffer::DeliverRecordedData() {
   rtc::CritScope lock(&lock_cb_);
   if (!audio_transport_cb_) {
     LOG(LS_WARNING) << "Invalid audio transport";
     return 0;
   }
   const size_t rec_bytes_per_sample = [&] {
     rtc::CritScope lock(&lock_);
     return rec_bytes_per_sample_;

[tommi, 2016/10/25 16:43:22]

nit: it seems unnecessarily fancy to use a lambda here. We could just have a
scope and cache the value locally.

[henrika_webrtc, 2016/10/26 12:42:41]

LOL, I did initially but kwiberg@ wanted me to use a lambda.

   }();
   uint32_t new_mic_level(0);
   uint32_t total_delay_ms = play_delay_ms_ + rec_delay_ms_;
   size_t num_samples = rec_buffer_.size() / rec_bytes_per_sample;
   int32_t res = audio_transport_cb_->RecordedDataIsAvailable(
       rec_buffer_.data(), num_samples, rec_bytes_per_sample_, rec_channels_,
       rec_sample_rate_, total_delay_ms, clock_drift_, current_mic_level_,
       typing_status_, new_mic_level);
   if (res != -1) {
     new_mic_level_ = new_mic_level;
@@ skipping 39 matching lines @@
     return 0;
   }
 
   // Retrieve new 16-bit PCM audio data using the audio transport instance.
   int64_t elapsed_time_ms = -1;
   int64_t ntp_time_ms = -1;
   size_t num_samples_out(0);
   uint32_t res = audio_transport_cb_->NeedMorePlayData(
       num_samples, play_bytes_per_sample_, play_channels, play_sample_rate_,
       play_buffer_.data(), num_samples_out, &elapsed_time_ms, &ntp_time_ms);
   if (res != 0) {

[tommi, 2016/10/25 16:43:22]

at this point, we don't need to hold |lock| but we actually hold it for the rest
of the function.  Can we add a scope around the usage of audio_transport_cb_?

[henrika_webrtc, 2016/10/26 12:42:41]

As mentioned; I am planning a separate "improve locking in the ADB class" CL but
this proposal is too good to resist so I am adding it ;-)

     LOG(LS_ERROR) << "NeedMorePlayData() failed";
   }
 
   // Derive a new level value twice per second.
   int16_t max_abs = 0;
   RTC_DCHECK_LT(play_stat_count_, 50);
   if (++play_stat_count_ >= 50) {
     const size_t size = num_samples * play_channels;
     // Returns the largest absolute value in a signed 16-bit vector.
     max_abs = WebRtcSpl_MaxAbsValueW16(
         reinterpret_cast<const int16_t*>(play_buffer_.data()), size);
     play_stat_count_ = 0;
   }
   // Update some stats but do it on the task queue to ensure that the members
   // are modified and read on the same thread. Note that |max_abs| will be
   // zero in most calls and then have no effect of the stats. It is only updated
   // approximately two times per second and can then change the stats.
-  task_queue_.PostTask(rtc::Bind(&AudioDeviceBuffer::UpdatePlayStats, this,
+  task_queue_->PostTask(rtc::Bind(&AudioDeviceBuffer::UpdatePlayStats, this,
                                  max_abs, num_samples_out));

[tommi, 2016/10/25 16:43:22]

fix indent (maybe run git cl format?)

[henrika_webrtc, 2016/10/26 12:42:41]

For some reason git cl format does not work on this CL. Don't know the exact
reason. I always use it. Will change.

I created a new CL and patched it with this one and did git cl format again. Did
not find any other misses than those you pointed out already.

   return static_cast<int32_t>(num_samples_out);
 }
 
 int32_t AudioDeviceBuffer::GetPlayoutData(void* audio_buffer) {
   RTC_DCHECK_GT(play_buffer_.size(), 0u);
   const size_t play_bytes_per_sample = [&] {
     rtc::CritScope lock(&lock_);
     return play_bytes_per_sample_;
   }();
   memcpy(audio_buffer, play_buffer_.data(), play_buffer_.size());
   return static_cast<int32_t>(play_buffer_.size() / play_bytes_per_sample);
 }
 
 void AudioDeviceBuffer::StartTimer() {
+  LOG(INFO) << "StartTimer";

[tommi, 2016/10/25 16:43:22]

do we need all of this logging in release builds?

[henrika_webrtc, 2016/10/26 12:42:40]

Removed

   num_stat_reports_ = 0;
   last_log_stat_time_ = rtc::TimeMillis();
-  task_queue_.PostDelayedTask(rtc::Bind(&AudioDeviceBuffer::LogStats, this),
-                              kTimerIntervalInMilliseconds);
+  task_queue_.reset(new rtc::TaskQueue(kTimerQueueName));
+  task_queue_->PostDelayedTask(rtc::Bind(&AudioDeviceBuffer::LogStats, this),
+                               kTimerIntervalInMilliseconds);
+}
+
+void AudioDeviceBuffer::StopTimer() {
+  LOG(INFO) << "StopTimer";
+  if (task_queue_) {

[tommi, 2016/10/25 16:43:23]

check isn't necessary (reset() handles it)

[henrika_webrtc, 2016/10/26 12:42:41]

Thanks!

+    task_queue_.reset(nullptr);
+  }
 }
 
 void AudioDeviceBuffer::LogStats() {
-  RTC_DCHECK(task_queue_.IsCurrent());
+  RTC_DCHECK(task_queue_->IsCurrent());
 
   int64_t now_time = rtc::TimeMillis();
   int64_t next_callback_time = now_time + kTimerIntervalInMilliseconds;
   int64_t time_since_last = rtc::TimeDiff(now_time, last_log_stat_time_);
   last_log_stat_time_ = now_time;
 
   // Log the latest statistics but skip the first 10 seconds since we are not
   // sure of the exact starting point. I.e., the first log printout will be
   // after ~20 seconds.
   if (++num_stat_reports_ > 1 && time_since_last > 0) {
@@ skipping 11 matching lines @@
     rate = diff_samples / (static_cast<float>(time_since_last) / 1000.0);
     LOG(INFO) << "[PLAY: " << time_since_last << "msec, "
               << play_sample_rate_ / 1000
               << "kHz] callbacks: " << play_callbacks_ - last_play_callbacks_
               << ", "
               << "samples: " << diff_samples << ", "
               << "rate: " << static_cast<int>(rate + 0.5) << ", "
               << "level: " << max_play_level_;
   }
 
-  // Count number of times we detect "no audio" corresponding to a case where
-  // all level measurements have been zero.
-  if (max_rec_level_ == 0) {
-    ++num_rec_level_is_zero_;
-  }
-
   last_rec_callbacks_ = rec_callbacks_;
   last_play_callbacks_ = play_callbacks_;
   last_rec_samples_ = rec_samples_;
   last_play_samples_ = play_samples_;
   max_rec_level_ = 0;
   max_play_level_ = 0;
 
   int64_t time_to_wait_ms = next_callback_time - rtc::TimeMillis();
   RTC_DCHECK_GT(time_to_wait_ms, 0) << "Invalid timer interval";
 
   // Update some stats but do it on the task queue to ensure that access of
   // members is serialized hence avoiding usage of locks.
-  task_queue_.PostDelayedTask(rtc::Bind(&AudioDeviceBuffer::LogStats, this),
-                              time_to_wait_ms);
+  task_queue_->PostDelayedTask(rtc::Bind(&AudioDeviceBuffer::LogStats, this),
+                               time_to_wait_ms);
 }
 
 void AudioDeviceBuffer::ResetRecStats() {
+  rec_start_time_ = rtc::TimeMillis();
   rec_callbacks_ = 0;
   last_rec_callbacks_ = 0;
   rec_samples_ = 0;
   last_rec_samples_ = 0;
   max_rec_level_ = 0;
-  num_rec_level_is_zero_ = 0;
+  only_silence_recorded_ = true;
 }
 
 void AudioDeviceBuffer::ResetPlayStats() {
-  last_playout_time_ = rtc::TimeMillis();
+  const uint64_t now_time = rtc::TimeMillis();
+  play_start_time_ = now_time;
+  last_playout_time_ = now_time;
   play_callbacks_ = 0;
   last_play_callbacks_ = 0;
   play_samples_ = 0;
   last_play_samples_ = 0;
   max_play_level_ = 0;
 }
 
 void AudioDeviceBuffer::UpdateRecStats(int16_t max_abs, size_t num_samples) {
-  RTC_DCHECK(task_queue_.IsCurrent());
+  RTC_DCHECK(task_queue_->IsCurrent());
   ++rec_callbacks_;
   rec_samples_ += num_samples;
   if (max_abs > max_rec_level_) {
     max_rec_level_ = max_abs;
   }
 }
 
 void AudioDeviceBuffer::UpdatePlayStats(int16_t max_abs, size_t num_samples) {
-  RTC_DCHECK(task_queue_.IsCurrent());
+  RTC_DCHECK(task_queue_->IsCurrent());
   ++play_callbacks_;
   play_samples_ += num_samples;
   if (max_abs > max_play_level_) {
     max_play_level_ = max_abs;
   }
 }
 
 }  // namespace webrtc