Support for AudioContextOptions latencyHint.

content/renderer/media/renderer_webaudiodevice_impl.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/renderer/media/renderer_webaudiodevice_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 
@@ skipping 10 matching lines @@
 
 using blink::WebAudioDevice;
 using blink::WebLocalFrame;
 using blink::WebVector;
 using blink::WebView;
 
 namespace content {
 
 RendererWebAudioDeviceImpl::RendererWebAudioDeviceImpl(
     const media::AudioParameters& params,
+    const AudioDeviceFactory::SourceType source_type,
     WebAudioDevice::RenderCallback* callback,
     int session_id,
     const url::Origin& security_origin)
-    : params_(params),
+    : sink_params_(params),

[o1ka, 2016/11/15 22:44:27]

There is no point in passing these params. Sink will calculate them.

Instead of getting sink parameters from untrusted sources ;) (such as mixer
code) and telling them to the sink:

(1) params are not passed to constructor: only channel layout and latency  (2)
WebAudioDeviceImpl gets output parameters from AudioDevice factory, adjusts
buffer size basing on latency ("switch" part of "mixer" code), sets channel
layout - and that will be |sink_params_| (3) WebAudio gets those adjusted params
from WebAudioDevice through getters and uses them to configure rendering (fifo,
etc) (4) WebAudioDeviceImpl passes adjusted params to sink->Initialize().

Or am I missing something?

[Andrew MacPherson, 2016/11/16 10:58:29]

This makes perfect sense to me, thanks for the detailed clarification!

Should the switch statement that converts LatencyType to buffer size be made
into an AudioLatency static member since it will be used in two places now? And
do we need to pass 'channels' into the RendererWebAudioDevice constructor as
well so that it can do set_channels_for_discrete() on the params?

+      source_type_(source_type),
       client_callback_(callback),
       session_id_(session_id),
       security_origin_(security_origin) {
   DCHECK(client_callback_);
 }
 
 RendererWebAudioDeviceImpl::~RendererWebAudioDeviceImpl() {
   DCHECK(!sink_);
 }
 
 void RendererWebAudioDeviceImpl::start() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (sink_)
     return;  // Already started.
 
   // Assumption: This method is being invoked within a V8 call stack.  CHECKs
   // will fail in the call to frameForCurrentContext() otherwise.
   //
   // Therefore, we can perform look-ups to determine which RenderView is
   // starting the audio device.  The reason for all this is because the creator
   // of the WebAudio objects might not be the actual source of the audio (e.g.,
   // an extension creates a object that is passed and used within a page).
   WebLocalFrame* const web_frame = WebLocalFrame::frameForCurrentContext();
   RenderFrame* const render_frame =
       web_frame ? RenderFrame::FromWebFrame(web_frame) : NULL;
   sink_ = AudioDeviceFactory::NewAudioRendererSink(
-      AudioDeviceFactory::kSourceWebAudioInteractive,
+      source_type_,
       render_frame ? render_frame->GetRoutingID() : MSG_ROUTING_NONE,
       session_id_, std::string(), security_origin_);
 
-  // Specify the latency info to be passed to the browser side.
-  media::AudioParameters sink_params(params_);
-  sink_params.set_latency_tag(AudioDeviceFactory::GetSourceLatencyType(
-      AudioDeviceFactory::kSourceWebAudioInteractive));
-
 #if defined(OS_ANDROID)
   // Use the media thread instead of the render thread for fake Render() calls
   // since it has special connotations for Blink and garbage collection. Timeout
   // value chosen to be highly unlikely in the normal case.
   webaudio_suspender_.reset(new media::SilentSinkSuspender(
-      this, base::TimeDelta::FromSeconds(30), sink_params, sink_,
+      this, base::TimeDelta::FromSeconds(30), sink_params_, sink_,
       RenderThreadImpl::current()->GetMediaThreadTaskRunner()));
-  sink_->Initialize(sink_params, webaudio_suspender_.get());
+  sink_->Initialize(sink_params_, webaudio_suspender_.get());
 #else
-  sink_->Initialize(sink_params, this);
+  sink_->Initialize(sink_params_, this);
 #endif
 
   sink_->Start();
   sink_->Play();
 }
 
 void RendererWebAudioDeviceImpl::stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (sink_) {
     sink_->Stop();
     sink_ = nullptr;
   }
 
 #if defined(OS_ANDROID)
   webaudio_suspender_.reset();
 #endif
 }
 
 double RendererWebAudioDeviceImpl::sampleRate() {
-  return params_.sample_rate();
+  return sink_params_.sample_rate();
+}
+
+int RendererWebAudioDeviceImpl::framesPerBuffer() {
+  return sink_params_.frames_per_buffer();
 }
 
 int RendererWebAudioDeviceImpl::Render(media::AudioBus* dest,
                                        uint32_t frames_delayed,
                                        uint32_t frames_skipped) {
   // Wrap the output pointers using WebVector.
   WebVector<float*> web_audio_dest_data(static_cast<size_t>(dest->channels()));
   for (int i = 0; i < dest->channels(); ++i)
     web_audio_dest_data[i] = dest->channel(i);
 
   // TODO(xians): Remove the following |web_audio_source_data| after
   // changing the blink interface.
   WebVector<float*> web_audio_source_data(static_cast<size_t>(0));
   client_callback_->render(web_audio_source_data, web_audio_dest_data,
                            dest->frames());
   return dest->frames();
 }
 
 void RendererWebAudioDeviceImpl::OnRenderError() {
   // TODO(crogers): implement error handling.
 }
 
 }  // namespace content