Support for AudioContextOptions latencyHint.

content/renderer/media/renderer_webaudiodevice_impl.cc

Index: content/renderer/media/renderer_webaudiodevice_impl.cc
diff --git a/content/renderer/media/renderer_webaudiodevice_impl.cc b/content/renderer/media/renderer_webaudiodevice_impl.cc
index fc698e4d6a3fb43a79d3e4e844bf4b6344285b4e..ebed6e98b845a3643253c2aa31b9dcdd0cabbe69 100644
--- a/content/renderer/media/renderer_webaudiodevice_impl.cc
+++ b/content/renderer/media/renderer_webaudiodevice_impl.cc
@@ -20,22 +20,85 @@
 #include "third_party/WebKit/public/web/WebView.h"
 
 using blink::WebAudioDevice;
+using blink::WebAudioLatencyHint;
 using blink::WebLocalFrame;
 using blink::WebVector;
 using blink::WebView;
 
+namespace {

[o1ka, 2016/11/30 11:46:26]

nit: you can move unnamed namespace into |content| and avoid "content::"

[Andrew MacPherson, 2016/12/01 12:11:56]

Done.

+
+content::AudioDeviceFactory::SourceType GetLatencyHintSourceType(
+    WebAudioLatencyHint::Category latency_category) {
+  switch (latency_category) {
+    case WebAudioLatencyHint::CategoryInteractive:
+      return content::AudioDeviceFactory::kSourceWebAudioInteractive;
+    case WebAudioLatencyHint::CategoryBalanced:
+      return content::AudioDeviceFactory::kSourceWebAudioBalanced;
+    case WebAudioLatencyHint::CategoryPlayback:
+      return content::AudioDeviceFactory::kSourceWebAudioPlayback;
+  }
+  NOTREACHED();
+  return content::AudioDeviceFactory::kSourceWebAudioInteractive;
+}
+
+}  // namespace
+
 namespace content {
 
 RendererWebAudioDeviceImpl::RendererWebAudioDeviceImpl(
-    const media::AudioParameters& params,
+    media::ChannelLayout layout,
+    const blink::WebAudioLatencyHint& latency_hint,
     WebAudioDevice::RenderCallback* callback,
     int session_id,
     const url::Origin& security_origin)
-    : params_(params),
+    : latency_hint_(latency_hint),

[o1ka, 2016/11/30 11:46:26]

It does not look like you need |latency_hint_| anywhere. Store source type
instead?

[Andrew MacPherson, 2016/12/01 12:11:56]

The idea with storing the latency_hint_ was that it may be necessary when we add
the EXACT_MS latency type value member, but you're right that it's not required
right now so I can change it if that's best.

       client_callback_(callback),
       session_id_(session_id),
       security_origin_(security_origin) {
   DCHECK(client_callback_);
+
+  blink::WebLocalFrame* const web_frame =
+      blink::WebLocalFrame::frameForCurrentContext();
+  RenderFrame* const render_frame = RenderFrame::FromWebFrame(web_frame);

[o1ka, 2016/11/30 11:46:26]

Make FrameIdFromCurrentContext() helper function, or store it in the object for
reuse. (we also need to keep a comment from l.114 and make sure it is actually
valid in constructor)

[Andrew MacPherson, 2016/12/01 12:11:56]

Done except for the check in the constructor. Should it just be a DCHECK that we
have a valid render_frame or is something else required?

+  media::AudioParameters hardware_params(
+      AudioDeviceFactory::GetOutputDeviceInfo(render_frame->GetRoutingID(),
+                                              session_id_, std::string(),
+                                              security_origin_)
+          .output_params());
+
+  int output_buffer_size = 0;
+
+  media::AudioLatency::LatencyType latency =
+      AudioDeviceFactory::GetSourceLatencyType(
+          GetLatencyHintSourceType(latency_hint_.category()));
+
+  // Adjust output buffer size according to the latency requirement.
+  switch (latency) {
+    case media::AudioLatency::LATENCY_INTERACTIVE:
+      output_buffer_size = media::AudioLatency::GetInteractiveBufferSize(
+          hardware_params.frames_per_buffer());
+      break;
+    case media::AudioLatency::LATENCY_RTC:
+      output_buffer_size = media::AudioLatency::GetRtcBufferSize(
+          hardware_params.sample_rate(), hardware_params.frames_per_buffer());
+      break;
+    case media::AudioLatency::LATENCY_PLAYBACK:
+      output_buffer_size = media::AudioLatency::GetHighLatencyBufferSize(
+          hardware_params.sample_rate(), 0);
+      break;
+    case media::AudioLatency::LATENCY_EXACT_MS:
+    // TODO(olka): add support when WebAudio requires it.
+    default:
+      NOTREACHED();
+  }
+
+  DCHECK_NE(output_buffer_size, 0);
+
+  sink_params_.Reset(media::AudioParameters::AUDIO_PCM_LOW_LATENCY, layout,
+                     hardware_params.sample_rate(), 16, output_buffer_size);
+
+  // Specify the latency info to be passed to the browser side.
+  sink_params_.set_latency_tag(latency);
 }
 
 RendererWebAudioDeviceImpl::~RendererWebAudioDeviceImpl() {
@@ -59,25 +122,20 @@ void RendererWebAudioDeviceImpl::start() {
   RenderFrame* const render_frame =
       web_frame ? RenderFrame::FromWebFrame(web_frame) : NULL;
   sink_ = AudioDeviceFactory::NewAudioRendererSink(
-      AudioDeviceFactory::kSourceWebAudioInteractive,
+      GetLatencyHintSourceType(latency_hint_.category()),
       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();
@@ -97,7 +155,11 @@ void RendererWebAudioDeviceImpl::stop() {
 }
 
 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,