Update last audio tick time during suspend and resume.

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 "base/power_monitor/power_monitor.h"
 #include "build/build_config.h"
 #include "media/audio/fake_audio_log_factory.h"
 
 namespace media {
 namespace {
 AudioManager* g_last_created = NULL;
 
 // 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 {
+class AudioManagerHelper : public base::PowerObserver {
  public:
   AudioManagerHelper() : max_hung_task_time_(base::TimeDelta::FromMinutes(1)) {}
-  ~AudioManagerHelper() {}
+  ~AudioManagerHelper() override {}
 
   void StartHangTimer(
       const scoped_refptr<base::SingleThreadTaskRunner>& monitor_task_runner) {
     CHECK(!monitor_task_runner_);
     monitor_task_runner_ = monitor_task_runner;
+    base::PowerMonitor::Get()->AddObserver(this);
     UpdateLastAudioThreadTimeTick();
     CrashOnAudioThreadHang();
   }
 
+  void OnSuspend() override {
+    base::AutoLock lock(hang_lock_);
+    last_audio_thread_timer_tick_ = base::TimeTicks::Now();
+  }
+
+  void OnResume() override {

[nasko, 2015/03/26 23:10:43]

Are we guaranteed that there will be no task execution between resuming and this
call? I wonder if this notification is done after executing some existing tasks
on the message loop, because that has the potential to cause the delayed crash
task to execute before the resume handler has run. Maybe add a guard boolean
that we set on suspend and reset on resume? 

[DaleCurtis, 2015/03/26 23:26:45]

Ah, I was going to do this, but thought it wasn't any better than what I have
now, but thinking about it more, you're right, it's better. Done!

+    OnSuspend();

[nasko, 2015/03/26 23:10:44]

nit: Why not add a private method that does the work and call it from both
observer methods? Calling OnSuspend handler when resuming is ... awkward.

[DaleCurtis, 2015/03/26 23:26:45]

No need anymore.

+  }
+
   // Runs on |monitor_task_runner| typically, but may be started on any thread.
   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)),
         max_hung_task_time_);
   }
@@ skipping 61 matching lines @@
 AudioManager* AudioManager::CreateForTesting() {
   return Create(g_helper.Pointer()->fake_log_factory());
 }
 
 // static
 AudioManager* AudioManager::Get() {
   return g_last_created;
 }
 
 }  // namespace media