Revert of Switching AudioOutputAuthorizationHandler from using AudioManager interface to AudioSystem one.

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/memory/ptr_util.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"
 #include "content/public/browser/media_device_id.h"
-#include "media/audio/audio_system.h"
 #include "media/base/limits.h"
 
 namespace {
 
 media::AudioParameters TryToFixAudioParameters(
     const media::AudioParameters& params) {
   DCHECK(!params.IsValid());
   media::AudioParameters params_copy(params);
 
   // If the number of output channels is greater than the maximum, use the
   // maximum allowed value. Hardware channels are ignored upstream, so it is
   // better to report a valid value if this is the only problem.
   if (params.channels() > media::limits::kMaxChannels) {
     DCHECK(params.channel_layout() == media::CHANNEL_LAYOUT_DISCRETE);
     params_copy.set_channels_for_discrete(media::limits::kMaxChannels);
   }
 
   // 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) {
+  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::AudioSystem* audio_system,
+    media::AudioManager* audio_manager,
     MediaStreamManager* media_stream_manager,
     int render_process_id,
     const std::string& salt)
-    : audio_system_(audio_system),
+    : 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) {
@@ skipping 117 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());
-  audio_system_->GetOutputStreamParameters(
-      raw_device_id,
+  base::PostTaskAndReplyWithResult(
+      // Note: In the case of a shutdown, the task to delete |audio_manager_| is
+      // posted to the audio thread after the IO thread is stopped, so the task
+      // to delete the audio manager hasn't been posted yet. This means that
+      // unretained is safe here.
+      // Mac is a special case. Since the audio manager lives on the UI thread
+      // on Mac, this task is posted to the UI thread, 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