Handle invalid hardware output parameters in AudioRendererHost.

content/browser/renderer_host/media/audio_renderer_host.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 "content/browser/renderer_host/media/audio_renderer_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
@@ skipping 44 matching lines @@
                                                 int render_view_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (render_view_id == MSG_ROUTING_NONE || !ResourceDispatcherHostImpl::Get())
     return;
 
   ResourceDispatcherHostImpl::Get()->OnAudioRenderHostStreamStateChanged(
       render_process_id, render_view_id, is_playing);
 }
 
 media::AudioParameters DummyParams() {
-  return media::AudioParameters(media::AudioParameters::AUDIO_PCM_LINEAR,
-                                media::CHANNEL_LAYOUT_STEREO,
-                                media::limits::kMinSampleRate, 1, 1);
+  return media::AudioParameters(
+      media::AudioParameters::AUDIO_FAKE, media::CHANNEL_LAYOUT_STEREO,
+      media::AudioParameters::kAudioCDSampleRate, 16,
+      media::AudioParameters::kAudioCDSampleRate / 10);
 }
 
 std::pair<int, std::pair<bool, std::string>> MakeAuthorizationData(
     int stream_id,
     bool authorized,
     const std::string& device_unique_id) {
   return std::make_pair(stream_id,
                         std::make_pair(authorized, device_unique_id));
 }
 
@@ skipping 40 matching lines @@
 void NotifyRenderProcessHostThatAudioStateChanged(int render_process_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   RenderProcessHost* render_process_host =
       RenderProcessHost::FromID(render_process_id);
 
   if (render_process_host)
     render_process_host->AudioStateChanged();
 }
 
+void MaybeFixAudioParameters(media::AudioParameters* 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)
+    params->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.
+  if (!params->IsValid())
+    *params = DummyParams();
+}
+
 }  // namespace
 
 class AudioRendererHost::AudioEntry
     : public media::AudioOutputController::EventHandler {
  public:
   AudioEntry(AudioRendererHost* host,
              int stream_id,
              int render_frame_id,
              const media::AudioParameters& params,
              const std::string& output_device_id,
@@ skipping 289 matching lines @@
     if (info) {
       media::AudioParameters output_params(
           media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
           static_cast<media::ChannelLayout>(
               info->device.matched_output.channel_layout),
           info->device.matched_output.sample_rate, 16,
           info->device.matched_output.frames_per_buffer);
       output_params.set_effects(info->device.matched_output.effects);
       authorizations_.insert(MakeAuthorizationData(
           stream_id, true, info->device.matched_output_device_id));
+      MaybeFixAudioParameters(&output_params);
       Send(new AudioMsg_NotifyDeviceAuthorized(
           stream_id, media::OUTPUT_DEVICE_STATUS_OK, output_params));
       return;
     }
   }
 
   authorizations_.insert(
       MakeAuthorizationData(stream_id, false, std::string()));
   GURL gurl_security_origin = ConvertToGURL(security_origin);
   CheckOutputDeviceAccess(
@@ skipping 55 matching lines @@
 
   if (!device_found) {
     authorizations_.erase(auth_data);
     Send(new AudioMsg_NotifyDeviceAuthorized(
         stream_id, media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND, DummyParams()));
     return;
   }
 
   auth_data->second.first = true;
   auth_data->second.second = device_info.unique_id;
+
+  media::AudioParameters output_params = device_info.output_params;
+  MaybeFixAudioParameters(&output_params);
   Send(new AudioMsg_NotifyDeviceAuthorized(
-      stream_id, media::OUTPUT_DEVICE_STATUS_OK, device_info.output_params));
+      stream_id, media::OUTPUT_DEVICE_STATUS_OK, output_params));
 }
 
 void AudioRendererHost::OnCreateStream(int stream_id,
                                        int render_frame_id,
                                        const media::AudioParameters& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "AudioRendererHost@" << this << "::OnCreateStream"
            << "(stream_id=" << stream_id << ")";
 
   const auto& auth_data = authorizations_.find(stream_id);
@@ skipping 287 matching lines @@
   callback.Run(false, device_info);
 }
 
 bool AudioRendererHost::IsAuthorizationStarted(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const auto& i = authorizations_.find(stream_id);
   return i != authorizations_.end();
 }
 
 }  // namespace content