Move chrome specific code from platform/audio/chromium to platform/audio

Source/platform/audio/AudioDestination.cpp

 /*
  * Copyright (C) 2010 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
@@ skipping 12 matching lines @@
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #if ENABLE(WEB_AUDIO)
 
-#include "platform/audio/chromium/AudioDestinationChromium.h"
+#include "platform/audio/AudioDestination.h"
 
 #include "platform/audio/AudioFIFO.h"
 #include "platform/audio/AudioPullFIFO.h"
 #include "public/platform/Platform.h"
 
 namespace WebCore {
 
 // Buffer size at which the web audio engine will render.
 const unsigned renderBufferSize = 128;
 
 // Size of the FIFO
 const size_t fifoSize = 8192;
 
 // Factory method: Chromium-implementation
 PassOwnPtr<AudioDestination> AudioDestination::create(AudioIOCallback& callback, const String& inputDeviceId, unsigned numberOfInputChannels, unsigned numberOfOutputChannels, float sampleRate)
 {
-    return adoptPtr(new AudioDestinationChromium(callback, inputDeviceId, numberOfInputChannels, numberOfOutputChannels, sampleRate));
+    return adoptPtr(new AudioDestination(callback, inputDeviceId, numberOfInputChannels, numberOfOutputChannels, sampleRate));
 }
 
-AudioDestinationChromium::AudioDestinationChromium(AudioIOCallback& callback, const String& inputDeviceId, unsigned numberOfInputChannels, unsigned numberOfOutputChannels, float sampleRate)
+AudioDestination::AudioDestination(AudioIOCallback& callback, const String& inputDeviceId, unsigned numberOfInputChannels, unsigned numberOfOutputChannels, float sampleRate)
     : m_callback(callback)
     , m_numberOfOutputChannels(numberOfOutputChannels)
     , m_inputBus(AudioBus::create(numberOfInputChannels, renderBufferSize))
     , m_renderBus(AudioBus::create(numberOfOutputChannels, renderBufferSize, false))
     , m_sampleRate(sampleRate)
     , m_isPlaying(false)
 {
     // Use the optimal buffer size recommended by the audio backend.
     m_callbackBufferSize = blink::Platform::current()->audioHardwareBufferSize();
 
@@ skipping 33 matching lines @@
 
     // If the callback size does not match the render size, then we need to buffer some
     // extra silence for the input. Otherwise, we can over-consume the input FIFO.
     if (m_callbackBufferSize != renderBufferSize) {
         // FIXME: handle multi-channel input and don't hard-code to stereo.
         RefPtr<AudioBus> silence = AudioBus::create(2, renderBufferSize);
         m_inputFifo->push(silence.get());
     }
 }
 
-AudioDestinationChromium::~AudioDestinationChromium()
+AudioDestination::~AudioDestination()
 {
     stop();
 }
 
-void AudioDestinationChromium::start()
+void AudioDestination::start()
 {
     if (!m_isPlaying && m_audioDevice) {
         m_audioDevice->start();
         m_isPlaying = true;
     }
 }
 
-void AudioDestinationChromium::stop()
+void AudioDestination::stop()
 {
     if (m_isPlaying && m_audioDevice) {
         m_audioDevice->stop();
         m_isPlaying = false;
     }
 }
 
 float AudioDestination::hardwareSampleRate()
 {
     return static_cast<float>(blink::Platform::current()->audioHardwareSampleRate());
 }
 
 unsigned long AudioDestination::maxChannelCount()
 {
     return static_cast<float>(blink::Platform::current()->audioHardwareOutputChannels());
 }
 
-void AudioDestinationChromium::render(const blink::WebVector<float*>& sourceData, const blink::WebVector<float*>& audioData, size_t numberOfFrames)
+void AudioDestination::render(const blink::WebVector<float*>& sourceData, const blink::WebVector<float*>& audioData, size_t numberOfFrames)
 {
     bool isNumberOfChannelsGood = audioData.size() == m_numberOfOutputChannels;
     if (!isNumberOfChannelsGood) {
         ASSERT_NOT_REACHED();
         return;
     }
 
     bool isBufferSizeGood = numberOfFrames == m_callbackBufferSize;
     if (!isBufferSizeGood) {
         ASSERT_NOT_REACHED();
         return;
     }
 
     // Buffer optional live input.
     if (sourceData.size() >= 2) {
         // FIXME: handle multi-channel input and don't hard-code to stereo.
         RefPtr<AudioBus> wrapperBus = AudioBus::create(2, numberOfFrames, false);
         wrapperBus->setChannelMemory(0, sourceData[0], numberOfFrames);
         wrapperBus->setChannelMemory(1, sourceData[1], numberOfFrames);
         m_inputFifo->push(wrapperBus.get());
     }
 
     for (unsigned i = 0; i < m_numberOfOutputChannels; ++i)
         m_renderBus->setChannelMemory(i, audioData[i], numberOfFrames);
 
     m_fifo->consume(m_renderBus.get(), numberOfFrames);
 }
 
-void AudioDestinationChromium::provideInput(AudioBus* bus, size_t framesToProcess)
+void AudioDestination::provideInput(AudioBus* bus, size_t framesToProcess)
 {
     AudioBus* sourceBus = 0;
     if (m_inputFifo->framesInFifo() >= framesToProcess) {
         m_inputFifo->consume(m_inputBus.get(), framesToProcess);
         sourceBus = m_inputBus.get();
     }
 
     m_callback.render(sourceBus, bus, framesToProcess);
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(WEB_AUDIO)