Attempt to fix audio wedges by restarting all streams.

media/audio/audio_output_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/audio_output_controller.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 197 matching lines @@
   // WedgeCheck() will look to see if |on_more_io_data_called_| is true after
   // the timeout expires.  Care must be taken to ensure the wedge check delay is
   // large enough that the value isn't queried while OnMoreDataIO() is setting
   // it.
   //
   // Timer self-manages its lifetime and WedgeCheck() will only record the UMA
   // statistic if state is still kPlaying.  Additional Start() calls will
   // invalidate the previous timer.
   wedge_timer_.reset(new base::OneShotTimer<AudioOutputController>());
   wedge_timer_->Start(
-      FROM_HERE, TimeDelta::FromSeconds(5), this,
+      FROM_HERE, TimeDelta::FromSeconds(1), this,

[scherkus (not reviewing), 2013/12/02 21:49:37]

FYI changing this value will impact the results of
Media.AudioOutputControllerPlaybackStartupSuccess, which means it's no longer
valid to view this histogram across all versions

[DaleCurtis, 2013/12/02 22:23:59]

For safety I'm going to revert this change.  Since most sounds are hung on
resume, usually due to background activation (i.e. without user interaction),
the 5 second timeout might be fine.  My hunch is users probably aren't aware
their audio is hung within that 5 second window.

       &AudioOutputController::WedgeCheck);
 
   handler_->OnPlaying();
 }
 
 #if defined(AUDIO_POWER_MONITORING)
 void AudioOutputController::ReportPowerMeasurementPeriodically() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   const std::pair<float, bool>& reading =
       power_monitor_.ReadCurrentPowerAndClip();
@@ skipping 239 matching lines @@
 void AudioOutputController::DisallowEntryToOnMoreIOData() {
   const bool is_zero = !base::AtomicRefCountDec(&num_allowed_io_);
   DCHECK(is_zero);
 }
 
 void AudioOutputController::WedgeCheck() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // If we should be playing and we haven't, that's a wedge.
   if (state_ == kPlaying) {
-    UMA_HISTOGRAM_BOOLEAN("Media.AudioOutputControllerPlaybackStartupSuccess",
-                          base::AtomicRefCountIsOne(&on_more_io_data_called_));
+    const bool playback_success =
+        base::AtomicRefCountIsOne(&on_more_io_data_called_);
+
+    UMA_HISTOGRAM_BOOLEAN(
+        "Media.AudioOutputControllerPlaybackStartupSuccess", playback_success);
+
+    // Let the AudioManager try and fix it.
+    if (!playback_success)
+      audio_manager_->FixWedgedAudio();

[scherkus (not reviewing), 2013/12/02 21:49:37]

Hmm I was under the impression we'd be landing a Mac-specific workaround. Do we
really want to land this workaround for all OSes when we don't really know if a
problem exists (and for that matter one that we can reproduce?)

For example, we only know that closing all streams fixes the problem on Mac.
That may not be true on other OSes.

Options include:
  1) #ifdef'ing just this bit of code
  2) #ifdef'ing all the code
  3) renaming / shuffling things, such as:
    - Rename FixWedgedAudio() to something like DetectedWedgedAudio()
    - Make the base class implementation do nothing
    - Have the Mac backend implement the workaround

My preference is for something like (3) as it limits the workaround to the
platform that needs it w/o sprinkling #ifdefs around

[DaleCurtis, 2013/12/02 22:23:59]

(3) is fine, I wanted to get the idea sanitized before I made it more specific.

[DaleCurtis, 2013/12/02 22:52:08]

Actually 3 wasn't possible since the fix requires private details of
AudioManagerBase to implement.  It's not so bad though, only a single #ifdef is
necessary.

   }
 }
 
 }  // namespace media