[DO NOT SUBMIT] AudioWorklet FS2: audio thread

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

 /*
  * Copyright (C) 2011, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 14 matching lines @@
 #include "modules/webaudio/DefaultAudioDestinationNode.h"
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/ExceptionCode.h"
 #include "modules/webaudio/AbstractAudioContext.h"
 #include "platform/Logging.h"
 
 namespace blink {
 
 DefaultAudioDestinationHandler::DefaultAudioDestinationHandler(AudioNode& node)
-    : AudioDestinationHandler(node, AudioDestination::hardwareSampleRate())
+    : AudioDestinationHandler(node, AudioRenderSink::audioHardwareSampleRate())
     , m_numberOfInputChannels(0)
 {
     // Node-specific default mixing rules.
     m_channelCount = 2;
     m_channelCountMode = Explicit;
     m_channelInterpretation = AudioBus::Speakers;
 }
 
 PassRefPtr<DefaultAudioDestinationHandler> DefaultAudioDestinationHandler::create(AudioNode& node)
 {
@@ skipping 10 matching lines @@
     uninitialize();
     AudioDestinationHandler::dispose();
 }
 
 void DefaultAudioDestinationHandler::initialize()
 {
     ASSERT(isMainThread());
     if (isInitialized())
         return;
 
-    createDestination();
+    createRenderSink();
     AudioHandler::initialize();
 }
 
 void DefaultAudioDestinationHandler::uninitialize()
 {
     ASSERT(isMainThread());
     if (!isInitialized())
         return;
 
-    m_destination->stop();
+    m_audioRenderSink->stop();
     m_numberOfInputChannels = 0;
 
     AudioHandler::uninitialize();
 }
 
-void DefaultAudioDestinationHandler::createDestination()
+void DefaultAudioDestinationHandler::createRenderSink()
 {
-    float hardwareSampleRate = AudioDestination::hardwareSampleRate();
-    VLOG(1) << ">>>> hardwareSampleRate = " << hardwareSampleRate;
+    float audioHardwareSampleRate = AudioRenderSink::audioHardwareSampleRate();
+    VLOG(1) << ">>>> hardwareSampleRate = " << audioHardwareSampleRate;
 
-    m_destination = AudioDestination::create(*this, m_inputDeviceId, m_numberOfInputChannels, channelCount(), hardwareSampleRate, context()->getSecurityOrigin());
+    m_audioRenderSink = AudioRenderSink::create(*this,
+        m_inputDeviceId, m_numberOfInputChannels, channelCount(),
+        audioHardwareSampleRate, context()->getSecurityOrigin());
 }
 
 void DefaultAudioDestinationHandler::startRendering()
 {
     ASSERT(isInitialized());
-    if (isInitialized()) {
-        ASSERT(!m_destination->isPlaying());
-        m_destination->start();
-    }
+    if (isInitialized())
+        m_audioRenderSink->start();
 }
 
 void DefaultAudioDestinationHandler::stopRendering()
 {
     ASSERT(isInitialized());
-    if (isInitialized()) {
-        ASSERT(m_destination->isPlaying());
-        m_destination->stop();
-    }
+    if (isInitialized())
+        m_audioRenderSink->stop();
 }
 
 unsigned long DefaultAudioDestinationHandler::maxChannelCount() const
 {
-    return AudioDestination::maxChannelCount();
+    return AudioRenderSink::audioHardwareChannelCount();
 }
 
-void DefaultAudioDestinationHandler::setChannelCount(unsigned long channelCount, ExceptionState& exceptionState)
+void DefaultAudioDestinationHandler::setChannelCount(unsigned long newChannelCount, ExceptionState& exceptionState)
 {
-    // The channelCount for the input to this node controls the actual number of channels we
-    // send to the audio hardware. It can only be set depending on the maximum number of
-    // channels supported by the hardware.
+    // The channelCount for the input to this node controls the actual number of
+    // channels we send to the audio hardware. It can only be set depending on
+    // the maximum number of channels supported by the hardware.
+    ASSERT(isMainThread());
+    ASSERT(isInitialized());
+    if (!isInitialized())
+        return;
 
-    ASSERT(isMainThread());
-
-    if (!maxChannelCount() || channelCount > maxChannelCount()) {
+    if (!maxChannelCount() || newChannelCount > maxChannelCount()) {
         exceptionState.throwDOMException(
             IndexSizeError,
-            ExceptionMessages::indexOutsideRange<unsigned>("channel count", channelCount, 1, ExceptionMessages::InclusiveBound, maxChannelCount(), ExceptionMessages::InclusiveBound));
+            ExceptionMessages::indexOutsideRange<unsigned>("channel count", newChannelCount, 1, ExceptionMessages::InclusiveBound, maxChannelCount(), ExceptionMessages::InclusiveBound));
         return;
     }
 
-    unsigned long oldChannelCount = this->channelCount();
-    AudioHandler::setChannelCount(channelCount, exceptionState);
+    unsigned long oldChannelCount = channelCount();
+    AudioHandler::setChannelCount(newChannelCount, exceptionState);
 
-    if (!exceptionState.hadException() && this->channelCount() != oldChannelCount && isInitialized()) {
-        // Re-create destination.
-        m_destination->stop();
-        createDestination();
-        m_destination->start();
+    // Restart render sink to apply the channel count change.
+    if (!exceptionState.hadException() && channelCount() != oldChannelCount) {
+        m_audioRenderSink->stop();
+        createRenderSink();
+        m_audioRenderSink->start();
     }
 }
 
 // ----------------------------------------------------------------
 
 DefaultAudioDestinationNode::DefaultAudioDestinationNode(AbstractAudioContext& context)
     : AudioDestinationNode(context)
 {
     setHandler(DefaultAudioDestinationHandler::create(*this));
 }
 
 DefaultAudioDestinationNode* DefaultAudioDestinationNode::create(AbstractAudioContext* context)
 {
     return new DefaultAudioDestinationNode(*context);
 }
 
 } // namespace blink