Add a hang monitor for the audio thread.

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/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/audio/fake_audio_log_factory.h"
 
 namespace media {
 namespace {
 AudioManager* g_last_created = NULL;
-static base::LazyInstance<FakeAudioLogFactory>::Leaky g_fake_log_factory =
+
+// Helper class for managing global AudioManager data and hang timers. If the
+// audio thread is unresponsive for more than a minute we want to crash the
+// process so we can catch offenders quickly in the field.
+class AudioManagerHelper {
+ public:
+  AudioManagerHelper() : max_hung_task_time_(base::TimeDelta::FromMinutes(1)) {}
+  ~AudioManagerHelper() {}
+
+  void StartHangTimer(
+      const scoped_refptr<base::SingleThreadTaskRunner>& monitor_task_runner) {
+    CHECK(!monitor_task_runner_);

[nasko, 2015/03/25 17:28:00]

nit: Can we also check that this is called on the expected thread? Your comment
says it is on the IO thread, but you mentioned that on OSX it behaves
differently in the previous discussion.

[DaleCurtis, 2015/03/25 20:28:56]

Sent you a chat about this, because I'm not clear on exactly what you want to
verify here. The IO thread is just used to ensure we have an unblocked thread to
check on the audio thread (which may be its own thread or reuse the UI thread on
OSX).

On OSX this would essentially end up being a hang monitor for the UI thread;
which seems unnecessary since there's probably already one. So I'll probably add
a !OSX condition below.

[nasko, 2015/03/25 20:52:23]

Clarified over chat. Since this method isn't expected to execute on one specific
thread (platform specific details), we can't enforce a CURRENTLY_ON style check.

+    monitor_task_runner_ = monitor_task_runner;
+    UpdateLastAudioThreadTimeTick();
+    CrashOnAudioThreadHang();
+  }
+
+  void CrashOnAudioThreadHang() {
+    base::AutoLock lock(hang_lock_);
+    CHECK(base::TimeTicks::Now() - last_audio_thread_timer_tick_ <=
+          max_hung_task_time_);
+    monitor_task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(&AudioManagerHelper::CrashOnAudioThreadHang,
+                              base::Unretained(this)),

[nasko, 2015/03/25 17:28:00]

Are we guaranteed that this object will never be null?

[DaleCurtis, 2015/03/25 20:28:56]

Yes, it's a LazyInstance::Leaky, which means it'll be leaked at shutdown.

[nasko, 2015/03/25 20:52:23]

Acknowledged.

+        max_hung_task_time_);
+  }
+
+  void UpdateLastAudioThreadTimeTick() {
+    base::AutoLock lock(hang_lock_);
+    last_audio_thread_timer_tick_ = base::TimeTicks::Now();
+    g_last_created->GetTaskRunner()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&AudioManagerHelper::UpdateLastAudioThreadTimeTick,
+                   base::Unretained(this)),
+        max_hung_task_time_ / 2);
+  }
+
+  AudioLogFactory* fake_log_factory() { return &fake_log_factory_; }
+
+ private:
+  FakeAudioLogFactory fake_log_factory_;
+
+  const base::TimeDelta max_hung_task_time_;
+  scoped_refptr<base::SingleThreadTaskRunner> monitor_task_runner_;
+
+  base::Lock hang_lock_;
+  base::TimeTicks last_audio_thread_timer_tick_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioManagerHelper);
+};
+
+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);
+  g_helper.Pointer()->StartHangTimer(monitor_task_runner);
+  return manager;
+}
+
+// static
 AudioManager* AudioManager::CreateForTesting() {
-  return Create(g_fake_log_factory.Pointer());
+  return Create(g_helper.Pointer()->fake_log_factory());
 }
 
 // static
 AudioManager* AudioManager::Get() {
   return g_last_created;
 }
 
 }  // namespace media