Split "Online" and "Offline" AudioContext processing

Source/modules/webaudio/ScriptProcessorNode.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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 12 matching lines @@
  */
 
 #include "config.h"
 #if ENABLE(WEB_AUDIO)
 #include "modules/webaudio/ScriptProcessorNode.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/CrossThreadTask.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
+#include "modules/webaudio/AbstractAudioContext.h"
 #include "modules/webaudio/AudioBuffer.h"
-#include "modules/webaudio/AudioContext.h"
 #include "modules/webaudio/AudioNodeInput.h"
 #include "modules/webaudio/AudioNodeOutput.h"
 #include "modules/webaudio/AudioProcessingEvent.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
 ScriptProcessorHandler::ScriptProcessorHandler(AudioNode& node, float sampleRate, size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfOutputChannels)
     : AudioHandler(NodeTypeJavaScript, node, sampleRate)
     , m_doubleBufferIndex(0)
     , m_doubleBufferIndexForEvent(0)
     , m_bufferSize(bufferSize)
     , m_bufferReadWriteIndex(0)
     , m_numberOfInputChannels(numberOfInputChannels)
     , m_numberOfOutputChannels(numberOfOutputChannels)
     , m_internalInputBus(AudioBus::create(numberOfInputChannels, ProcessingSizeInFrames, false))
 {
     // Regardless of the allowed buffer sizes, we still need to process at the granularity of the AudioNode.
     if (m_bufferSize < ProcessingSizeInFrames)
         m_bufferSize = ProcessingSizeInFrames;
 
-    ASSERT(numberOfInputChannels <= AudioContext::maxNumberOfChannels());
+    ASSERT(numberOfInputChannels <= AbstractAudioContext::maxNumberOfChannels());
 
     addInput();
     addOutput(numberOfOutputChannels);
 
     m_channelCount = numberOfInputChannels;
     m_channelCountMode = Explicit;
 
     initialize();
 }
 
@@ skipping 143 matching lines @@
 }
 
 double ScriptProcessorHandler::latencyTime() const
 {
     return std::numeric_limits<double>::infinity();
 }
 
 void ScriptProcessorHandler::setChannelCount(unsigned long channelCount, ExceptionState& exceptionState)
 {
     ASSERT(isMainThread());
-    AudioContext::AutoLocker locker(context());
+    AbstractAudioContext::AutoLocker locker(context());
 
     if (channelCount != m_channelCount) {
         exceptionState.throwDOMException(
             NotSupportedError,
             "channelCount cannot be changed from " + String::number(m_channelCount) + " to " + String::number(channelCount));
     }
 }
 
 void ScriptProcessorHandler::setChannelCountMode(const String& mode, ExceptionState& exceptionState)
 {
     ASSERT(isMainThread());
-    AudioContext::AutoLocker locker(context());
+    AbstractAudioContext::AutoLocker locker(context());
 
     if ((mode == "max") || (mode == "clamped-max")) {
         exceptionState.throwDOMException(
             NotSupportedError,
             "channelCountMode cannot be changed from 'explicit' to '" + mode + "'");
     }
 }
 
 // ----------------------------------------------------------------
 
-ScriptProcessorNode::ScriptProcessorNode(AudioContext& context, float sampleRate, size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfOutputChannels)
+ScriptProcessorNode::ScriptProcessorNode(AbstractAudioContext& context, float sampleRate, size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfOutputChannels)
     : AudioNode(context)
 {
     setHandler(ScriptProcessorHandler::create(*this, sampleRate, bufferSize, numberOfInputChannels, numberOfOutputChannels));
 }
 
 static size_t chooseBufferSize()
 {
     // Choose a buffer size based on the audio hardware buffer size. Arbitarily make it a power of
     // two that is 4 times greater than the hardware buffer size.
     // FIXME: What is the best way to choose this?
     size_t hardwareBufferSize = Platform::current()->audioHardwareBufferSize();
     size_t bufferSize = 1 << static_cast<unsigned>(log2(4 * hardwareBufferSize) + 0.5);
 
     if (bufferSize < 256)
         return 256;
     if (bufferSize > 16384)
         return 16384;
 
     return bufferSize;
 }
 
-ScriptProcessorNode* ScriptProcessorNode::create(AudioContext& context, float sampleRate, size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfOutputChannels)
+ScriptProcessorNode* ScriptProcessorNode::create(AbstractAudioContext& context, float sampleRate, size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfOutputChannels)
 {
     // Check for valid buffer size.
     switch (bufferSize) {
     case 0:
         bufferSize = chooseBufferSize();
         break;
     case 256:
     case 512:
     case 1024:
     case 2048:
     case 4096:
     case 8192:
     case 16384:
         break;
     default:
         return nullptr;
     }
 
     if (!numberOfInputChannels && !numberOfOutputChannels)
         return nullptr;
 
-    if (numberOfInputChannels > AudioContext::maxNumberOfChannels())
+    if (numberOfInputChannels > AbstractAudioContext::maxNumberOfChannels())
         return nullptr;
 
-    if (numberOfOutputChannels > AudioContext::maxNumberOfChannels())
+    if (numberOfOutputChannels > AbstractAudioContext::maxNumberOfChannels())
         return nullptr;
 
     return new ScriptProcessorNode(context, sampleRate, bufferSize, numberOfInputChannels, numberOfOutputChannels);
 }
 
 size_t ScriptProcessorNode::bufferSize() const
 {
     return static_cast<ScriptProcessorHandler&>(handler()).bufferSize();
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)