[AudioService] OutputController snooping always on realtime thread.

Remove separate Snoopable modes "deferred" versus "realtime" and just
give all Snoopers access to the audio data in realtime, without any
copying or thread-hopping. This is to mitigate audio glitches when
using loopback on low-end machines that are CPU-limited, where normal
priority threads do not run their tasks often enough.

Moved the special "SanitizeAudioBus()" function closer to where it is
being used, with a simple "modify only if needed" mechanism. This
function was clamping the audio samples; but, by being in
audio::OutputController, this would mutate the audio data being
delivered to both the operating system as well as other Snoopers.

Bug: 960161
Change-Id: If91952462960f7c72562436ffeebb64498b5372f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1602312
Commit-Queue: Yuri Wiitala <miu@chromium.org>
Auto-Submit: Yuri Wiitala <miu@chromium.org>
Reviewed-by: Max Morin <maxmorin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#658304}

services/audio/input_controller.cc

@@ -11,6 +11,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
@@ -93,9 +94,62 @@ float AveragePower(const media::AudioBus& buffer) {
 #endif  // AUDIO_POWER_MONITORING
 
 #if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
+
 bool CanRunApm() {
   return base::FeatureList::IsEnabled(features::kWebRtcApmInAudioService);
 }
+
+bool SamplesNeedClamping(const media::AudioBus& bus) {
+  const auto IsOutOfRange = [](float sample) {
+    // See comment in CopySamplesWithClamping() for why the conditional is
+    // written this way.
+    if (UNLIKELY(!(sample >= -1.f && sample <= 1.f))) {
+      return true;
+    }
+    return false;
+  };
+
+  const int frames = bus.frames();
+  for (int i = 0; i < bus.channels(); ++i) {
+    auto* const channel = bus.channel(i);
+    if (UNLIKELY(std::any_of(channel, channel + frames, IsOutOfRange))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void CopySamplesWithClamping(const media::AudioBus& src_bus,
+                             media::AudioBus* dest_bus) {
+  DCHECK_EQ(src_bus.channels(), dest_bus->channels());
+  DCHECK_EQ(src_bus.frames(), dest_bus->frames());
+
+  const auto ToClampedSample = [](float sample) {
+    // First check for all the invalid cases with a single conditional to
+    // optimize for the typical (data ok) case. Different cases are handled
+    // inside of the conditional. The condition is written like this to catch
+    // NaN. It cannot be simplified to "channel[j] < -1.f || channel[j] > 1.f",
+    // which isn't equivalent.
+    if (UNLIKELY(!(sample >= -1.f && sample <= 1.f))) {
+      // Don't just set all bad values to 0. If a value like 1.0001 is produced
+      // due to floating-point shenanigans, 1 will sound better than 0.
+      if (sample < -1.f) {
+        return -1.f;
+      } else {
+        // channel[j] > 1 or NaN.
+        return 1.f;
+      }
+    }
+    return sample;
+  };
+
+  const int frames = src_bus.frames();
+  for (int i = 0; i < src_bus.channels(); ++i) {
+    auto* const src = src_bus.channel(i);
+    std::transform(src, src + frames, dest_bus->channel(i), ToClampedSample);
+  }
+}
+
 #endif  // defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
 
 }  // namespace
@@ -125,8 +179,7 @@ void InputController::ProcessingHelper::ChangeMonitoredStream(
     return;
 
   if (monitored_output_stream_) {
-    monitored_output_stream_->StopSnooping(this,
-                                           Snoopable::SnoopingMode::kRealtime);
+    monitored_output_stream_->StopSnooping(this);
     if (!stream) {
       audio_processor_->set_has_reverse_stream(false);
     }
@@ -134,24 +187,39 @@ void InputController::ProcessingHelper::ChangeMonitoredStream(
   monitored_output_stream_ = stream;
   if (!monitored_output_stream_) {
     output_params_ = media::AudioParameters();
+    clamped_bus_.reset();
     return;
   }
   output_params_ = monitored_output_stream_->GetAudioParameters();
   audio_processor_->set_has_reverse_stream(true);
-  monitored_output_stream_->StartSnooping(this,
-                                          Snoopable::SnoopingMode::kRealtime);
+  monitored_output_stream_->StartSnooping(this);
 }
 
 void InputController::ProcessingHelper::OnData(const media::AudioBus& audio_bus,
                                                base::TimeTicks reference_time,
                                                double volume) {
   TRACE_EVENT0("audio", "APM AnalyzePlayout");
+
   // OnData gets called when the InputController is snooping on an output stream
   // for audio processing purposes. |audio_bus| contains the data from the
   // snooped-upon output stream, not the input stream's data.
   // |volume| is applied in the WebRTC mixer in the renderer, so we don't have
   // to inform the |audio_processor_| of the new volume.
-  audio_processor_->AnalyzePlayout(audio_bus, output_params_, reference_time);
+
+  // If there are out-of-range samples, clamp them.
+  const media::AudioBus* bus_to_analyze = &audio_bus;
+  if (SamplesNeedClamping(audio_bus)) {
+    if (!clamped_bus_ || clamped_bus_->channels() != audio_bus.channels() ||
+        clamped_bus_->frames() != audio_bus.frames()) {
+      clamped_bus_ =
+          media::AudioBus::Create(audio_bus.channels(), audio_bus.frames());
+    }
+    CopySamplesWithClamping(audio_bus, clamped_bus_.get());
+    bus_to_analyze = clamped_bus_.get();
+  }
+
+  audio_processor_->AnalyzePlayout(*bus_to_analyze, output_params_,
+                                   reference_time);
 }
 
 void InputController::ProcessingHelper::GetStats(GetStatsCallback callback) {

services/audio/input_controller.h

@@ -230,6 +230,7 @@ class InputController final : public StreamMonitor {
     const std::unique_ptr<media::AudioProcessor> audio_processor_;
     media::AudioParameters output_params_;
     Snoopable* monitored_output_stream_ = nullptr;
+    std::unique_ptr<media::AudioBus> clamped_bus_;
   };
 #endif  // defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
 

services/audio/loopback_stream.cc

@@ -183,7 +183,7 @@ void LoopbackStream::OnMemberJoinedGroup(LoopbackGroupMember* member) {
       std::forward_as_tuple(input_params, network_->output_params()));
   DCHECK(emplace_result.second);  // There was no pre-existing map entry.
   SnooperNode* const snooper = &(emplace_result.first->second);
-  member->StartSnooping(snooper, Snoopable::SnoopingMode::kDeferred);
+  member->StartSnooping(snooper);
   network_->AddInput(snooper);
 }
 
@@ -199,7 +199,7 @@ void LoopbackStream::OnMemberLeftGroup(LoopbackGroupMember* member) {
   const auto snoop_it = snoopers_.find(member);
   DCHECK(snoop_it != snoopers_.end());
   SnooperNode* const snooper = &(snoop_it->second);
-  member->StopSnooping(snooper, Snoopable::SnoopingMode::kDeferred);
+  member->StopSnooping(snooper);
   network_->RemoveInput(snooper);
   snoopers_.erase(snoop_it);
 }

services/audio/output_controller.cc

@@ -53,31 +53,6 @@ void LogInitialStreamCreationResult(StreamCreationResult result) {
       STREAM_CREATION_RESULT_MAX + 1);
 }
 
-void SanitizeAudioBus(media::AudioBus* bus) {
-  size_t channel_size = bus->frames();
-  for (int i = 0; i < bus->channels(); ++i) {
-    float* channel = bus->channel(i);
-    for (size_t j = 0; j < channel_size; ++j) {
-      // First check for all the invalid cases with a single conditional to
-      // optimize for the typical (data ok) case. Different cases are handled
-      // inside of the conditional. The condition is written like this to catch
-      // NaN. It cannot be simplified to "channel[j] < -1.f || channel[j] >
-      // 1.f", which isn't equivalent.
-      if (UNLIKELY(!(channel[j] >= -1.f && channel[j] <= 1.f))) {
-        // Don't just set all bad values to 0. If a value like 1.0001 is
-        // produced due to floating-point shenanigans, 1 will sound better than
-        // 0.
-        if (channel[j] < -1.f) {
-          channel[j] = -1.f;
-        } else {
-          // channel[j] > 1 or NaN.
-          channel[j] = 1.f;
-        }
-      }
-    }
-  }
-}
-
 }  // namespace
 
 OutputController::ErrorStatisticsTracker::ErrorStatisticsTracker()
@@ -130,7 +105,6 @@ OutputController::OutputController(
       output_device_id_(output_device_id),
       stream_(NULL),
       disable_local_output_(false),
-      should_duplicate_(0),
       volume_(1.0),
       state_(kEmpty),
       sync_reader_(sync_reader),
@@ -152,7 +126,6 @@ OutputController::~OutputController() {
   DCHECK_EQ(kClosed, state_);
   DCHECK_EQ(nullptr, stream_);
   DCHECK(snoopers_.empty());
-  DCHECK(should_duplicate_.IsZero());
   UMA_HISTOGRAM_LONG_TIMES("Media.AudioOutputController.LifeTime",
                            base::TimeTicks::Now() - construction_time_);
 }
@@ -401,10 +374,12 @@ int OutputController::OnMoreData(base::TimeDelta delay,
   const base::TimeTicks reference_time = delay_timestamp + delay;
 
   if (!dest->is_bitstream_format()) {
-    base::AutoLock lock(realtime_snooper_lock_);
-    if (!realtime_snoopers_.empty()) {
-      SanitizeAudioBus(dest);
-      for (Snooper* snooper : realtime_snoopers_) {
+    base::AutoLock lock(snooper_lock_);
+    if (!snoopers_.empty()) {
+      TRACE_EVENT1("audio", "OutputController::BroadcastDataToSnoopers",
+                   "reference_time (ms)",
+                   (reference_time - base::TimeTicks()).InMillisecondsF());
+      for (Snooper* snooper : snoopers_) {
         snooper->OnData(*dest, reference_time, volume_);
       }
     }
@@ -417,15 +392,6 @@ int OutputController::OnMoreData(base::TimeDelta delay,
 
   sync_reader_->RequestMoreData(delay, delay_timestamp, prior_frames_skipped);
 
-  if (!should_duplicate_.IsZero() && !dest->is_bitstream_format()) {
-    std::unique_ptr<media::AudioBus> copy(media::AudioBus::Create(params_));
-    dest->CopyTo(copy.get());
-    task_runner_->PostTask(
-        FROM_HERE,
-        base::BindOnce(&OutputController::BroadcastDataToSnoopers,
-                       weak_this_for_stream_, std::move(copy), reference_time));
-  }
-
   if (will_monitor_audio_levels()) {
     // Note: this code path should never be hit when using bitstream streams.
     // Scan doesn't expect compressed audio, so it may go out of bounds trying
@@ -447,20 +413,6 @@ int OutputController::OnMoreData(base::TimeDelta delay,
   return frames;
 }
 
-void OutputController::BroadcastDataToSnoopers(
-    std::unique_ptr<media::AudioBus> audio_bus,
-    base::TimeTicks reference_time) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  TRACE_EVENT1("audio", "OutputController::BroadcastDataToSnoopers",
-               "reference_time (ms)",
-               (reference_time - base::TimeTicks()).InMillisecondsF());
-  if (state_ != kPlaying)
-    return;
-
-  for (Snooper* snooper : snoopers_)
-    snooper->OnData(*audio_bus, reference_time, volume_);
-}
-
 void OutputController::LogAudioPowerLevel(const char* call_name) {
   std::pair<float, bool> power_and_clip =
       power_monitor_.ReadCurrentPowerAndClip();
@@ -525,42 +477,28 @@ std::string OutputController::GetDeviceId() const {
              : output_device_id_;
 }
 
-void OutputController::StartSnooping(Snooper* snooper, SnoopingMode mode) {
+void OutputController::StartSnooping(Snooper* snooper) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(snooper);
 
-  if (mode == SnoopingMode::kDeferred) {
-    if (snoopers_.empty())
-      should_duplicate_.Increment();
-    DCHECK(!base::ContainsValue(snoopers_, snooper));
-    snoopers_.push_back(snooper);
-  } else {  // SnoopingMode::kRealtime
-    // The list will only update on this thread, but may be read from another.
-    DCHECK(!base::ContainsValue(realtime_snoopers_, snooper));
-    base::AutoLock lock(realtime_snooper_lock_);
-    realtime_snoopers_.push_back(snooper);
-  }
+  // The list will only update on this thread, and only be read on the realtime
+  // audio thread.
+  DCHECK(!base::ContainsValue(snoopers_, snooper));
+  base::AutoLock lock(snooper_lock_);
+  snoopers_.push_back(snooper);
 }
 
-void OutputController::StopSnooping(Snooper* snooper, SnoopingMode mode) {
+void OutputController::StopSnooping(Snooper* snooper) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  if (mode == SnoopingMode::kDeferred) {
-    const auto it = std::find(snoopers_.begin(), snoopers_.end(), snooper);
-    DCHECK(it != snoopers_.end());
-    snoopers_.erase(it);
-    if (snoopers_.empty())
-      should_duplicate_.Decrement();
-  } else {  // SnoopingMode::kRealtime
-    // The list will only update on this thread, but may be read from another.
-    const auto it = std::find(realtime_snoopers_.begin(),
-                              realtime_snoopers_.end(), snooper);
-    DCHECK(it != realtime_snoopers_.end());
-    // We also don't care about ordering, so swap and pop rather than erase.
-    base::AutoLock lock(realtime_snooper_lock_);
-    *it = realtime_snoopers_.back();
-    realtime_snoopers_.pop_back();
-  }
+  // The list will only update on this thread, and only be read on the realtime
+  // audio thread.
+  const auto it = std::find(snoopers_.begin(), snoopers_.end(), snooper);
+  DCHECK(it != snoopers_.end());
+  // We also don't care about ordering, so swap and pop rather than erase.
+  base::AutoLock lock(snooper_lock_);
+  *it = snoopers_.back();
+  snoopers_.pop_back();
 }
 
 void OutputController::StartMuting() {

services/audio/output_controller.h

@@ -155,8 +155,8 @@ class OutputController : public media::AudioOutputStream::AudioSourceCallback,
   // LoopbackGroupMember implementation.
   const media::AudioParameters& GetAudioParameters() const override;
   std::string GetDeviceId() const override;
-  void StartSnooping(Snooper* snooper, SnoopingMode mode) override;
-  void StopSnooping(Snooper* snooper, SnoopingMode mode) override;
+  void StartSnooping(Snooper* snooper) override;
+  void StopSnooping(Snooper* snooper) override;
   void StartMuting() override;
   void StopMuting() override;
 
@@ -243,10 +243,6 @@ class OutputController : public media::AudioOutputStream::AudioSourceCallback,
   // Helper method that stops, closes, and NULLs |*stream_|.
   void StopCloseAndClearStream();
 
-  // Send audio data to each Snooper.
-  void BroadcastDataToSnoopers(std::unique_ptr<media::AudioBus> audio_bus,
-                               base::TimeTicks reference_time);
-
   // Log the current average power level measured by power_monitor_.
   void LogAudioPowerLevel(const char* call_name);
 
@@ -276,14 +272,10 @@ class OutputController : public media::AudioOutputStream::AudioSourceCallback,
   // diverted to |diverting_to_stream_|, or a fake AudioOutputStream.
   bool disable_local_output_;
 
-  // The targets for audio stream to be copied to. |should_duplicate_| is set to
-  // 1 when the OnMoreData() call should proxy the data to
-  // BroadcastDataToSnoopers().
+  // The snoopers examining or grabbing a copy of the audio data from the
+  // OnMoreData() calls.
+  base::Lock snooper_lock_;
   std::vector<Snooper*> snoopers_;
-  base::AtomicRefCount should_duplicate_;
-
-  base::Lock realtime_snooper_lock_;
-  std::vector<Snooper*> realtime_snoopers_;
 
   // The current volume of the audio stream.
   double volume_;

services/audio/output_controller_unittest.cc

@@ -415,8 +415,8 @@ class OutputControllerTest : public ::testing::Test {
     Mock::VerifyAndClearExpectations(&mock_event_handler_);
   }
 
-  void StartSnooping(MockSnooper* snooper, Snoopable::SnoopingMode mode) {
-    controller_->StartSnooping(snooper, mode);
+  void StartSnooping(MockSnooper* snooper) {
+    controller_->StartSnooping(snooper);
   }
 
   void WaitForSnoopedData(MockSnooper* snooper) {
@@ -428,8 +428,8 @@ class OutputControllerTest : public ::testing::Test {
     Mock::VerifyAndClearExpectations(snooper);
   }
 
-  void StopSnooping(MockSnooper* snooper, Snoopable::SnoopingMode mode) {
-    controller_->StopSnooping(snooper, mode);
+  void StopSnooping(MockSnooper* snooper) {
+    controller_->StopSnooping(snooper);
   }
 
   Snoopable* GetSnoopable() { return &(*controller_); }
@@ -609,72 +609,68 @@ TEST_F(OutputControllerTest, PlayMuteUnmuteClose) {
   EXPECT_EQ(playout_stream, last_closed_stream());
 }
 
-class WithSnoopingMode
-    : public OutputControllerTest,
-      public ::testing::WithParamInterface<Snoopable::SnoopingMode> {};
-
-TEST_P(WithSnoopingMode, SnoopCreatePlayStopClose) {
+TEST_F(OutputControllerTest, SnoopCreatePlayStopClose) {
   NiceMock<MockSnooper> snooper;
-  StartSnooping(&snooper, GetParam());
+  StartSnooping(&snooper);
   Create();
   Play();
   WaitForSnoopedData(&snooper);
-  StopSnooping(&snooper, GetParam());
+  StopSnooping(&snooper);
   Close();
 }
 
-TEST_P(WithSnoopingMode, CreatePlaySnoopStopClose) {
+TEST_F(OutputControllerTest, CreatePlaySnoopStopClose) {
   NiceMock<MockSnooper> snooper;
   Create();
   Play();
-  StartSnooping(&snooper, GetParam());
+  StartSnooping(&snooper);
   WaitForSnoopedData(&snooper);
-  StopSnooping(&snooper, GetParam());
+  StopSnooping(&snooper);
   Close();
 }
 
-TEST_P(WithSnoopingMode, CreatePlaySnoopCloseStop) {
+TEST_F(OutputControllerTest, CreatePlaySnoopCloseStop) {
   NiceMock<MockSnooper> snooper;
   Create();
   Play();
-  StartSnooping(&snooper, GetParam());
+  StartSnooping(&snooper);
   WaitForSnoopedData(&snooper);
   Close();
-  StopSnooping(&snooper, GetParam());
+  StopSnooping(&snooper);
 }
 
-TEST_P(WithSnoopingMode, TwoSnoopers_StartAtDifferentTimes) {
+TEST_F(OutputControllerTest, TwoSnoopers_StartAtDifferentTimes) {
   NiceMock<MockSnooper> snooper1;
   NiceMock<MockSnooper> snooper2;
-  StartSnooping(&snooper1, GetParam());
+  StartSnooping(&snooper1);
   Create();
   Play();
   WaitForSnoopedData(&snooper1);
-  StartSnooping(&snooper2, GetParam());
+  StartSnooping(&snooper2);
   WaitForSnoopedData(&snooper2);
   WaitForSnoopedData(&snooper1);
   WaitForSnoopedData(&snooper2);
   Close();
-  StopSnooping(&snooper1, GetParam());
-  StopSnooping(&snooper2, GetParam());
+  StopSnooping(&snooper1);
+  StopSnooping(&snooper2);
 }
 
-TEST_P(WithSnoopingMode, TwoSnoopers_StopAtDifferentTimes) {
+TEST_F(OutputControllerTest, TwoSnoopers_StopAtDifferentTimes) {
   NiceMock<MockSnooper> snooper1;
   NiceMock<MockSnooper> snooper2;
   Create();
   Play();
-  StartSnooping(&snooper1, GetParam());
+  StartSnooping(&snooper1);
   WaitForSnoopedData(&snooper1);
-  StartSnooping(&snooper2, GetParam());
+  StartSnooping(&snooper2);
   WaitForSnoopedData(&snooper2);
-  StopSnooping(&snooper1, GetParam());
+  StopSnooping(&snooper1);
   WaitForSnoopedData(&snooper2);
   Close();
-  StopSnooping(&snooper2, GetParam());
+  StopSnooping(&snooper2);
 }
 
-TEST_P(WithSnoopingMode, SnoopWhileMuting) {
+TEST_F(OutputControllerTest, SnoopWhileMuting) {
   NiceMock<MockSnooper> snooper;
 
   StartMutingBeforePlaying();
@@ -691,13 +687,13 @@ TEST_P(WithSnoopingMode, SnoopWhileMuting) {
   EXPECT_EQ(nullptr, last_closed_stream());
   EXPECT_EQ(AudioParameters::AUDIO_FAKE, mute_stream->format());
 
-  StartSnooping(&snooper, GetParam());
+  StartSnooping(&snooper);
   ASSERT_EQ(mute_stream, last_created_stream());
   EXPECT_EQ(nullptr, last_closed_stream());
   EXPECT_EQ(AudioParameters::AUDIO_FAKE, mute_stream->format());
   WaitForSnoopedData(&snooper);
 
-  StopSnooping(&snooper, GetParam());
+  StopSnooping(&snooper);
   ASSERT_EQ(mute_stream, last_created_stream());
   EXPECT_EQ(nullptr, last_closed_stream());
   EXPECT_EQ(AudioParameters::AUDIO_FAKE, mute_stream->format());
@@ -707,11 +703,6 @@ TEST_P(WithSnoopingMode, SnoopWhileMuting) {
   EXPECT_EQ(mute_stream, last_closed_stream());
 }
 
-INSTANTIATE_TEST_SUITE_P(OutputControllerSnoopingTest,
-                         WithSnoopingMode,
-                         ::testing::Values(Snoopable::SnoopingMode::kDeferred,
-                                           Snoopable::SnoopingMode::kRealtime));
-
 TEST_F(OutputControllerTest, InformsStreamMonitorsAlreadyInGroup) {
   MockStreamMonitor monitor;
   EXPECT_CALL(monitor, OnStreamActive(GetSnoopable()));

services/audio/snoopable.h

@@ -19,7 +19,9 @@ class Snoopable {
  public:
   class Snooper {
    public:
-    // Provides read-only access to the data flowing through a GroupMember.
+    // Provides read-only access to the data flowing through a GroupMember. This
+    // must execute quickly, as it will typically be called on a realtime
+    // thread; otherwise, audio glitches may occur.
     virtual void OnData(const media::AudioBus& audio_bus,
                         base::TimeTicks reference_time,
                         double volume) = 0;
@@ -28,11 +30,6 @@ class Snoopable {
     virtual ~Snooper() = default;
   };
 
-  enum class SnoopingMode {
-    kDeferred,  // Deferred snooping is done on the audio thread.
-    kRealtime   // Realtime snooping is done on the device thread. Must be fast!
-  };
-
   // Returns the audio parameters of the snoopable audio data. The parameters
   // must not change for the lifetime of this group member, but can be different
   // than those of other members.
@@ -42,11 +39,8 @@ class Snoopable {
   virtual std::string GetDeviceId() const = 0;
 
   // Starts/Stops snooping on the audio data flowing through this group member.
-  // The snooping modes are handled individually, so it's possible (though
-  // inadvisable) to call StartSnooping twice with the same snooper, but with
-  // different modes.
-  virtual void StartSnooping(Snooper* snooper, SnoopingMode mode) = 0;
-  virtual void StopSnooping(Snooper* snooper, SnoopingMode mode) = 0;
+  virtual void StartSnooping(Snooper* snooper) = 0;
+  virtual void StopSnooping(Snooper* snooper) = 0;
 
  protected:
   virtual ~Snoopable() = default;

services/audio/snooper_node_unittest.cc

@@ -200,7 +200,7 @@ class SnooperNodeTest : public testing::TestWithParam<InputAndOutputParams> {
     group_member_->SetVolume(kSourceVolume);
 
     node_.emplace(input_params(), output_params());
-    group_member_->StartSnooping(node(), Snoopable::SnoopingMode::kDeferred);
+    group_member_->StartSnooping(node());
 
     consumer_.emplace(output_params().channels(),
                       output_params().sample_rate());

services/audio/test/fake_loopback_group_member.cc

@@ -67,14 +67,12 @@ std::string FakeLoopbackGroupMember::GetDeviceId() const {
   return media::AudioDeviceDescription::kDefaultDeviceId;
 }
 
-void FakeLoopbackGroupMember::StartSnooping(Snooper* snooper,
-                                            SnoopingMode mode) {
+void FakeLoopbackGroupMember::StartSnooping(Snooper* snooper) {
   CHECK(!snooper_);
   snooper_ = snooper;
 }
 
-void FakeLoopbackGroupMember::StopSnooping(Snooper* snooper,
-                                           SnoopingMode mode) {
+void FakeLoopbackGroupMember::StopSnooping(Snooper* snooper) {
   snooper_ = nullptr;
 }
 

services/audio/test/fake_loopback_group_member.h

@@ -50,8 +50,8 @@ class FakeLoopbackGroupMember : public LoopbackGroupMember {
   // LoopbackGroupMember implementation.
   const media::AudioParameters& GetAudioParameters() const override;
   std::string GetDeviceId() const override;
-  void StartSnooping(Snooper* snooper, SnoopingMode mode) override;
-  void StopSnooping(Snooper* snooper, SnoopingMode mode) override;
+  void StartSnooping(Snooper* snooper) override;
+  void StopSnooping(Snooper* snooper) override;
   void StartMuting() override;
   void StopMuting() override;
 

services/audio/test/mock_group_member.h

@@ -21,8 +21,8 @@ class MockGroupMember : public LoopbackGroupMember {
 
   MOCK_CONST_METHOD0(GetAudioParameters, const media::AudioParameters&());
   MOCK_CONST_METHOD0(GetDeviceId, std::string());
-  MOCK_METHOD2(StartSnooping, void(Snooper* snooper, SnoopingMode mode));
-  MOCK_METHOD2(StopSnooping, void(Snooper* snooper, SnoopingMode mode));
+  MOCK_METHOD1(StartSnooping, void(Snooper* snooper));
+  MOCK_METHOD1(StopSnooping, void(Snooper* snooper));
   MOCK_METHOD0(StartMuting, void());
   MOCK_METHOD0(StopMuting, void());
   MOCK_METHOD0(IsMuting, bool());