Switch audio hang monitor to default-off. Enable for non-beta,stable.

media/audio/audio_manager.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_manager.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/synchronization/waitable_event.h"
 #include "build/build_config.h"
 #include "media/audio/fake_audio_log_factory.h"
+#include "media/base/media_switches.h"
 
 namespace media {
 namespace {
 AudioManager* g_last_created = NULL;
 
 // Maximum number of failed pings to the audio thread allowed. A crash will be
 // issued once this count is reached.  We require at least two pings before
 // crashing to ensure unobservable power events aren't mistakenly caught (e.g.,
 // the system suspends before a OnSuspend() event can be fired.).
 const int kMaxHangFailureCount = 2;
@@ skipping 88 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> monitor_task_runner_;
 
   base::Lock hang_lock_;
   bool hang_detection_enabled_;
   base::TimeTicks last_audio_thread_timer_tick_;
   int hang_failures_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioManagerHelper);
 };
 
+static bool g_hang_monitor_enabled = false;
+
 static base::LazyInstance<AudioManagerHelper>::Leaky g_helper =
     LAZY_INSTANCE_INITIALIZER;
 }
 
 // Forward declaration of the platform specific AudioManager factory function.
 AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory);
 
 AudioManager::AudioManager() {}
 
 AudioManager::~AudioManager() {
   CHECK(!g_last_created || g_last_created == this);
   g_last_created = NULL;
 }
 
 // static
 AudioManager* AudioManager::Create(AudioLogFactory* audio_log_factory) {
   CHECK(!g_last_created);
   g_last_created = CreateAudioManager(audio_log_factory);
   return g_last_created;
 }
 
 // static
 AudioManager* AudioManager::CreateWithHangTimer(
     AudioLogFactory* audio_log_factory,
     const scoped_refptr<base::SingleThreadTaskRunner>& monitor_task_runner) {
   AudioManager* manager = Create(audio_log_factory);
-  // On OSX the audio thread is the UI thread, for which a hang monitor is not
-  // necessary.
-#if !defined(OS_MACOSX)
-  g_helper.Pointer()->StartHangTimer(monitor_task_runner);
-#endif
+  if (g_hang_monitor_enabled ||
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableAudioHangMonitor)) {
+    g_helper.Pointer()->StartHangTimer(monitor_task_runner);
+  }
   return manager;
 }
 
 // static
 AudioManager* AudioManager::CreateForTesting() {
   AudioManager* manager = Create(g_helper.Pointer()->fake_log_factory());
 
   // When created for testing, always ensure all methods are ready to run (even
   // if they end up called from other threads.
   if (!manager->GetTaskRunner()->BelongsToCurrentThread()) {
     base::WaitableEvent event(false, false);
     manager->GetTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event)));
     event.Wait();
   }
 
   return manager;
 }
 
 // static
+void AudioManager::EnableHangMonitor() {
+  CHECK(!g_last_created);
+// On OSX the audio thread is the UI thread, for which a hang monitor is not
+// necessary or recommended.  If it's manually requested, we should allow it
+// to start though.
+#if !defined(OS_MACOSX)
+  g_hang_monitor_enabled = true;
+#endif
+}
+
+// static
 AudioManager* AudioManager::Get() {
   return g_last_created;
 }
 
 }  // namespace media