Support AudioContextOptions latencyHint as double.

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 23 matching lines @@
 AudioDeviceFactory::SourceType GetLatencyHintSourceType(
     WebAudioLatencyHint::AudioContextLatencyCategory latency_category) {
   switch (latency_category) {
     case WebAudioLatencyHint::kCategoryInteractive:
       return AudioDeviceFactory::kSourceWebAudioInteractive;
     case WebAudioLatencyHint::kCategoryBalanced:
       return AudioDeviceFactory::kSourceWebAudioBalanced;
     case WebAudioLatencyHint::kCategoryPlayback:
       return AudioDeviceFactory::kSourceWebAudioPlayback;
     case WebAudioLatencyHint::kCategoryExact:
-      // TODO implement CategoryExact
-      return AudioDeviceFactory::kSourceWebAudioInteractive;
+      return AudioDeviceFactory::kSourceWebAudioExact;
   }
   NOTREACHED();
   return AudioDeviceFactory::kSourceWebAudioInteractive;
 }
 
+int GetOutputBufferSize(const blink::WebAudioLatencyHint& latency_hint,
+                        const media::AudioLatency::LatencyType latency,
+                        const media::AudioParameters& hardware_params) {
+  // Adjust output buffer size according to the latency requirement.
+  switch (latency) {
+    case media::AudioLatency::LATENCY_INTERACTIVE:
+      return media::AudioLatency::GetInteractiveBufferSize(
+          hardware_params.frames_per_buffer());
+      break;
+    case media::AudioLatency::LATENCY_RTC:
+      return media::AudioLatency::GetRtcBufferSize(
+          hardware_params.sample_rate(), hardware_params.frames_per_buffer());
+      break;
+    case media::AudioLatency::LATENCY_PLAYBACK:
+      return media::AudioLatency::GetHighLatencyBufferSize(

[DaleCurtis, 2017/03/28 17:34:07]

I wonder if we should just replace this with GetExactBufferSize(0.2s, params).
We can do that in a followup though.

[Andrew MacPherson, 2017/03/29 08:34:09]

Sounds good!

+          hardware_params.sample_rate(), 0);
+      break;
+    case media::AudioLatency::LATENCY_EXACT_MS:
+      return media::AudioLatency::GetExactBufferSize(latency_hint.seconds(),
+                                                     hardware_params);
+      break;
+    default:
+      NOTREACHED();
+  }
+  return 0;
+}
+
 int FrameIdFromCurrentContext() {
   // 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).
   blink::WebLocalFrame* const web_frame =
       blink::WebLocalFrame::frameForCurrentContext();
@@ skipping 39 matching lines @@
       client_callback_(callback),
       session_id_(session_id),
       security_origin_(security_origin),
       frame_id_(render_frame_id_cb.Run()) {
   DCHECK(client_callback_);
   DCHECK_NE(frame_id_, MSG_ROUTING_NONE);
 
   media::AudioParameters hardware_params(device_params_cb.Run(
       frame_id_, session_id_, std::string(), security_origin_));
 
-  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();
-  }
-
+          GetLatencyHintSourceType(latency_hint.category()));
+  int output_buffer_size =
+      GetOutputBufferSize(latency_hint_, latency, hardware_params);
   DCHECK_NE(output_buffer_size, 0);
 
   sink_params_.Reset(media::AudioParameters::AUDIO_PCM_LOW_LATENCY, layout,
                      hardware_params.sample_rate(), 16, output_buffer_size);
   // Always set channels, this should be a no-op in all but the discrete case;
   // this call will fail if channels doesn't match the layout in other cases.
   sink_params_.set_channels_for_discrete(channels);
 
   // Specify the latency info to be passed to the browser side.
   sink_params_.set_latency_tag(latency);
@@ skipping 84 matching lines @@
 const scoped_refptr<base::SingleThreadTaskRunner>&
 RendererWebAudioDeviceImpl::GetMediaTaskRunner() {
   if (!media_task_runner_) {
     media_task_runner_ =
         RenderThreadImpl::current()->GetMediaThreadTaskRunner();
   }
   return media_task_runner_;
 }
 
 }  // namespace content