Support for AudioContextOptions latencyHint.

third_party/WebKit/Source/modules/webaudio/AudioContext.cpp

 // Copyright 2015 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 "modules/webaudio/AudioContext.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/frame/UseCounter.h"
 #include "modules/webaudio/AudioBufferCallback.h"
+#include "modules/webaudio/AudioContextOptions.h"
 #include "platform/Histogram.h"
 #include "platform/audio/AudioUtilities.h"
+#include "public/platform/WebAudioLatencyHint.h"
 
 #if DEBUG_AUDIONODE_REFERENCES
 #include <stdio.h>
 #endif
 
 namespace blink {
 
+namespace {
+
+WebAudioLatencyHint::Category LatencyHintCategoryFromString(String category) {
+  WebAudioLatencyHint::Category latencyCategory;
+  if (category == "interactive") {
+    latencyCategory = WebAudioLatencyHint::CategoryInteractive;
+  } else if (category == "balanced") {
+    latencyCategory = WebAudioLatencyHint::CategoryBalanced;
+  } else if (category == "playback") {
+    latencyCategory = WebAudioLatencyHint::CategoryPlayback;
+  } else {
+    NOTREACHED();
+    latencyCategory = WebAudioLatencyHint::CategoryInteractive;
+  }
+  return latencyCategory;
+}
+
+}  // namespace
+
 // Don't allow more than this number of simultaneous AudioContexts
 // talking to hardware.
 const unsigned MaxHardwareContexts = 6;
 static unsigned s_hardwareContextCount = 0;
 static unsigned s_contextId = 0;
 
 AudioContext* AudioContext::create(Document& document,
+                                   const AudioContextOptions& contextOptions,
+                                   ExceptionState& exceptionState) {
+  WebAudioLatencyHint::Category latencyCategory =
+      WebAudioLatencyHint::CategoryInteractive;
+  if (contextOptions.latencyHint().isAudioContextLatencyCategory()) {
+    latencyCategory = LatencyHintCategoryFromString(
+        contextOptions.latencyHint().getAsAudioContextLatencyCategory());
+  }
+  // TODO: add support for latencyHint().isDouble()
+
+  return AudioContext::create(document, latencyCategory, exceptionState);
+}
+
+AudioContext* AudioContext::create(Document& document,
+                                   const WebAudioLatencyHint& latencyHint,
                                    ExceptionState& exceptionState) {
   DCHECK(isMainThread());
 
   UseCounter::countCrossOriginIframe(document,
                                      UseCounter::AudioContextCrossOriginIframe);
 
   if (s_hardwareContextCount >= MaxHardwareContexts) {
     exceptionState.throwDOMException(
         NotSupportedError, ExceptionMessages::indexExceedsMaximumBound(
                                "number of hardware contexts",
                                s_hardwareContextCount, MaxHardwareContexts));
     return nullptr;
   }
 
-  AudioContext* audioContext = new AudioContext(document);
+  AudioContext* audioContext = new AudioContext(document, latencyHint);
   audioContext->suspendIfNeeded();
 
   if (!AudioUtilities::isValidAudioBufferSampleRate(
           audioContext->sampleRate())) {
     exceptionState.throwDOMException(
         NotSupportedError,
         ExceptionMessages::indexOutsideRange(
             "hardware sample rate", audioContext->sampleRate(),
             AudioUtilities::minAudioBufferSampleRate(),
             ExceptionMessages::InclusiveBound,
@@ skipping 21 matching lines @@
                       ("WebAudio.AudioContext.MaxChannelsAvailable"));
   DEFINE_STATIC_LOCAL(SparseHistogram, sampleRateHistogram,
                       ("WebAudio.AudioContext.HardwareSampleRate"));
   maxChannelCountHistogram.sample(
       audioContext->destination()->maxChannelCount());
   sampleRateHistogram.sample(audioContext->sampleRate());
 
   return audioContext;
 }
 
-AudioContext::AudioContext(Document& document)
-    : BaseAudioContext(&document), m_contextId(s_contextId++) {}
+AudioContext::AudioContext(Document& document,
+                           const WebAudioLatencyHint& latencyHint)
+    : BaseAudioContext(&document, latencyHint), m_contextId(s_contextId++) {}
 
 AudioContext::~AudioContext() {
 #if DEBUG_AUDIONODE_REFERENCES
   fprintf(stderr, "[%16p]: AudioContext::~AudioContext(): %u\n", this,
           m_contextId);
 #endif
 }
 
 DEFINE_TRACE(AudioContext) {
   visitor->trace(m_closeResolver);
@@ skipping 100 matching lines @@
   DCHECK(isMainThread());
   DCHECK(destination());
 
   if (contextState() == Running) {
     destination()->audioDestinationHandler().stopRendering();
     setContextState(Suspended);
     deferredTaskHandler().clearHandlersToBeDeleted();
   }
 }
 
+double AudioContext::baseLatency() const {
+  return framesPerBuffer() * 2 / static_cast<double>(sampleRate());
+}
+
 }  // namespace blink