Fix shutdown crash in AudioOutputAuthorizationHandler.

content/browser/renderer_host/media/audio_output_authorization_handler.cc

 // Copyright 2016 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 "content/browser/renderer_host/media/audio_output_authorization_handler.h"
 
 #include "base/task_runner_util.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 16 matching lines @@
   }
 
   // If hardware parameters are still invalid, use dummy parameters with
   // fake audio path and let the client handle the error.
   return params_copy.IsValid()
              ? params_copy
              : media::AudioParameters::UnavailableDeviceParams();
 }
 
 media::AudioParameters GetDeviceParametersOnDeviceThread(
+    media::AudioManager* audio_manager,
     const std::string& unique_id) {
-  media::AudioManager* audio_manager = media::AudioManager::Get();
   DCHECK(audio_manager->GetTaskRunner()->BelongsToCurrentThread());
 
   return media::AudioDeviceDescription::IsDefaultDevice(unique_id)
              ? audio_manager->GetDefaultOutputStreamParameters()
              : audio_manager->GetOutputStreamParameters(unique_id);
 }
 
 }  // namespace
 
 namespace content {
 
 AudioOutputAuthorizationHandler::AudioOutputAuthorizationHandler(
+    media::AudioManager* audio_manager,
     MediaStreamManager* media_stream_manager,
     int render_process_id,
     const std::string& salt)
-    : media_stream_manager_(media_stream_manager),
-      permission_checker_(new MediaDevicesPermissionChecker()),
+    : audio_manager_(audio_manager),
+      media_stream_manager_(media_stream_manager),
+      permission_checker_(base::MakeUnique<MediaDevicesPermissionChecker>()),
       render_process_id_(render_process_id),
       salt_(salt),
       weak_factory_(this) {
   DCHECK(media_stream_manager_);
 }
 
 void AudioOutputAuthorizationHandler::OverridePermissionsForTesting(
     bool override_value) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   permission_checker_.reset(new MediaDevicesPermissionChecker(override_value));
@@ skipping 116 matching lines @@
   cb.Run(media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND, false,
          media::AudioParameters::UnavailableDeviceParams(), std::string());
 }
 
 void AudioOutputAuthorizationHandler::GetDeviceParameters(
     AuthorizationCompletedCallback cb,
     const std::string& raw_device_id) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!raw_device_id.empty());
   base::PostTaskAndReplyWithResult(
-      media::AudioManager::Get()->GetTaskRunner(), FROM_HERE,
-      base::Bind(&GetDeviceParametersOnDeviceThread, raw_device_id),
+      // Note: |*audio_manager_| outlives the IO thread, so unretained is safe.

[o1ka, 2016/11/24 13:17:35]

|audio_manager_| is deleted on audio manager thread after IO message loop
destruction.

[Max Morin, 2016/11/24 14:12:20]

Well, it's a bit more complicated since audio manager must not only outlive
posting the task, but also executing the task, which is does since the task to
delete it is posted after the IO thread is stopped.

[o1ka, 2016/11/24 14:34:01]

Yes, it's exactly what I'm pointing to. It's not enough for audio_manager to
outlive the IO thread.
(and remove *)

[Max Morin, 2016/11/24 14:49:03]

Done in the latest patch set.

[o1ka, 2016/11/24 15:11:54]

Acknowledged.

+      // Mac is a special case. On Mac, this task is posted to the UI thread,

[o1ka, 2016/11/24 13:17:35]

because audio managers tuns on UI thread there.

[Max Morin, 2016/11/24 14:12:20]

Done.

+      // but tasks posted to the UI task runner will be ignored when the
+      // shutdown has progressed to deleting the audio manager, so this is still
+      // safe.
+      audio_manager_->GetTaskRunner(), FROM_HERE,
+      base::Bind(&GetDeviceParametersOnDeviceThread,
+                 base::Unretained(audio_manager_), raw_device_id),
       base::Bind(&AudioOutputAuthorizationHandler::DeviceParametersReceived,
                  weak_factory_.GetWeakPtr(), std::move(cb), false,
                  raw_device_id));
 }
 
 void AudioOutputAuthorizationHandler::DeviceParametersReceived(
     AuthorizationCompletedCallback cb,
     bool should_send_id,
     const std::string& raw_device_id,
     const media::AudioParameters& output_params) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!raw_device_id.empty());
 
   cb.Run(media::OUTPUT_DEVICE_STATUS_OK, should_send_id,
          output_params.IsValid() ? output_params
                                  : TryToFixAudioParameters(output_params),
          raw_device_id);
 }
 
 }  // namespace content