Avoid shutdown crash if audio thread is hung.

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 <stdint.h>
 
 #include <utility>
 
@@ skipping 63 matching lines @@
     io_task_running_ = audio_task_running_ = true;
     audio_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&AudioManagerHelper::UpdateLastAudioThreadTimeTick,
                    base::Unretained(this)));
     monitor_task_runner_->PostTask(
         FROM_HERE, base::Bind(&AudioManagerHelper::RecordAudioThreadStatus,
                               base::Unretained(this)));
   }
 
+  bool IsAudioThreadHung() {
+    base::AutoLock lock(hang_lock_);
+    return audio_thread_status_ == THREAD_HUNG;

[pfeldman, 2017/06/14 22:38:30]

We should not sync UI thread with potentially stalled audio one.

[alokp, 2017/06/14 23:56:19]

This function is only called during shutdown. Are you worried that audio-thread
would have acquired |hang_lock_| before stalling?

+  }
+
   base::SingleThreadTaskRunner* monitor_task_runner() const {
     return monitor_task_runner_.get();
   }
   AudioLogFactory* fake_log_factory() { return &fake_log_factory_; }
 
 #if defined(OS_WIN)
   // This should be called before creating an AudioManager in tests to ensure
   // that the creating thread is COM initialized.
   void InitializeCOMForTesting() {
     com_initializer_for_testing_.reset(new base::win::ScopedCOMInitializer());
@@ skipping 103 matching lines @@
     // Don't hold the lock while posting the next task.
     audio_task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AudioManagerHelper::UpdateLastAudioThreadTimeTick,
                    base::Unretained(this)),
         max_hung_task_time_ / 5);
   }
 
   void HistogramThreadStatus(ThreadStatus status) {
     DCHECK(monitor_task_runner_->BelongsToCurrentThread());
+    hang_lock_.AssertAcquired();
     audio_thread_status_ = status;
     UMA_HISTOGRAM_ENUMERATION("Media.AudioThreadStatus", audio_thread_status_,
                               THREAD_MAX + 1);
   }
 
   FakeAudioLogFactory fake_log_factory_;
 
   const base::TimeDelta max_hung_task_time_ = base::TimeDelta::FromMinutes(1);
   scoped_refptr<base::SingleThreadTaskRunner> monitor_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_;
@@ skipping 105 matching lines @@
 const std::string& AudioManager::GetGlobalAppName() {
   return GetHelper()->app_name();
 }
 #endif
 
 // static
 AudioManager* AudioManager::Get() {
   return g_last_created;
 }
 
-void AudioManager::Shutdown() {
+bool AudioManager::Shutdown() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
+  // Do not attempt to stop the audio thread if it is hung.
+  // Otherwise the current thread will hang too: crbug.com/729494
+  // TODO(olka, grunell): Will be fixed when audio is its own process.
+  if (GetHelper()->IsAudioThreadHung())

[pfeldman, 2017/06/14 22:38:31]

Are you suggesting that upon stopping the audio thread caller is joined and that
causes caller thread to hang? In this case you can try stopping this thread via
anther IO-type thread not sensitive to the stall (FILE?).

Also, what if you haven't yet updated status to HUNG? For example, failed_pings_
== 2. So we are hanging, but we don't know about it yet.

[alokp, 2017/06/14 23:56:19]

Yes - exactly.
AudioManager::Shutdown is currently called *after* all threads have been stopped
(see BrowserMainLoop::ShutdownThreadsAndCleanUp). So it is not possible to use
any other thread with current design.

That said, lifetime of audio thread is only tied to IO thread. Audio thread must
be stopped *after* joining IO thread since the IO thread posts tasks to the
audio thread that must run to achieve clean shutdown. I am not sure if it is
worth the complexity though since media team is actively working on moving the
audio service into a separate process. Dale?
Yeah this is best effort. There is no guarantee that audio thread will not stall
between now and the time it is actually joined.

+    return false;
+
   // TODO(alokp): Suspend hang monitor.
-
   if (audio_thread_->GetTaskRunner()->BelongsToCurrentThread()) {
     ShutdownOnAudioThread();
   } else {
     audio_thread_->GetTaskRunner()->PostTask(
         FROM_HERE, base::Bind(&AudioManager::ShutdownOnAudioThread,
                               base::Unretained(this)));
   }
   audio_thread_->Stop();
   shutdown_ = true;
+  return true;
 }
 
 }  // namespace media