Index: Source/modules/webaudio/OfflineAudioContext.cpp |
diff --git a/Source/modules/webaudio/OfflineAudioContext.cpp b/Source/modules/webaudio/OfflineAudioContext.cpp |
index ef1b020f57b51823ece020ab011aad12160c66ca..b95e4da61988f5074ebc95145d4682c63b41c476 100644 |
--- a/Source/modules/webaudio/OfflineAudioContext.cpp |
+++ b/Source/modules/webaudio/OfflineAudioContext.cpp |
@@ -32,13 +32,7 @@ |
#include "core/dom/Document.h" |
#include "core/dom/ExceptionCode.h" |
#include "core/dom/ExecutionContext.h" |
-#include "modules/webaudio/OfflineAudioCompletionEvent.h" |
-#include "modules/webaudio/OfflineAudioDestinationNode.h" |
-#include "platform/Task.h" |
-#include "platform/ThreadSafeFunctional.h" |
#include "platform/audio/AudioUtilities.h" |
-#include "public/platform/Platform.h" |
- |
namespace blink { |
@@ -99,8 +93,6 @@ |
OfflineAudioContext::OfflineAudioContext(Document* document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate) |
: AbstractAudioContext(document, numberOfChannels, numberOfFrames, sampleRate) |
- , m_isRenderingStarted(false) |
- , m_totalRenderFrames(numberOfFrames) |
{ |
} |
@@ -108,86 +100,19 @@ |
{ |
} |
-DEFINE_TRACE(OfflineAudioContext) |
-{ |
- visitor->trace(m_completeResolver); |
- AbstractAudioContext::trace(visitor); |
-} |
- |
-bool OfflineAudioContext::shouldSuspendNow() |
-{ |
- ASSERT(!isMainThread()); |
- |
- // If there is any scheduled suspend at |currentSampleFrame|, the context |
- // should be suspended. |
- if (!m_scheduledSuspends.contains(currentSampleFrame())) |
- return false; |
- |
- return true; |
-} |
- |
-void OfflineAudioContext::resolvePendingSuspendPromises() |
-{ |
- ASSERT(!isMainThread()); |
- |
- // Find a suspend scheduled at |currentSampleFrame| and resolve the |
- // associated promise on the main thread. |
- SuspendContainerMap::iterator it = m_scheduledSuspends.find(currentSampleFrame()); |
- if (it == m_scheduledSuspends.end()) |
- return; |
- |
- ScheduledSuspendContainer* suspendContainer = it->value; |
- m_scheduledSuspends.remove(it); |
- |
- // Passing a raw pointer |suspendContainer| is safe here because it is |
- // created/managed/destructed on the main thread. Also it is guaranteed to |
- // be alive until the task is finished somewhere else. |
- Platform::current()->mainThread()->postTask(FROM_HERE, |
- threadSafeBind(&OfflineAudioContext::resolveSuspendContainerOnMainThread, this, AllowCrossThreadAccess(suspendContainer))); |
-} |
- |
-void OfflineAudioContext::fireCompletionEvent() |
-{ |
- ASSERT(isMainThread()); |
- |
- // We set the state to closed here so that the oncomplete event handler sees |
- // that the context has been closed. |
- setContextState(Closed); |
- |
- AudioBuffer* renderedBuffer = renderTarget(); |
- |
- ASSERT(renderedBuffer); |
- if (!renderedBuffer) |
- return; |
- |
- // Avoid firing the event if the document has already gone away. |
- if (executionContext()) { |
- // Call the offline rendering completion event listener and resolve the |
- // promise too. |
- dispatchEvent(OfflineAudioCompletionEvent::create(renderedBuffer)); |
- m_completeResolver->resolve(renderedBuffer); |
- } else { |
- // The resolver should be rejected when the execution context is gone. |
- m_completeResolver->reject(DOMException::create(InvalidStateError, |
- "the execution context does not exist")); |
- } |
-} |
- |
ScriptPromise OfflineAudioContext::startOfflineRendering(ScriptState* scriptState) |
{ |
- ASSERT(isMainThread()); |
- |
// Calling close() on an OfflineAudioContext is not supported/allowed, |
- // but it might well have been closed by its execution context. |
+ // but it might well have been stopped by its execution context. |
if (isContextClosed()) { |
return ScriptPromise::rejectWithDOMException( |
scriptState, |
DOMException::create( |
InvalidStateError, |
- "cannot call startRendering on an OfflineAudioContext in a closed state.")); |
+ "cannot call startRendering on an OfflineAudioContext in a stopped state.")); |
} |
- if (m_completeResolver) { |
+ if (m_offlineResolver) { |
// Can't call startRendering more than once. Return a rejected promise now. |
return ScriptPromise::rejectWithDOMException( |
scriptState, |
@@ -196,24 +121,9 @@ |
"cannot call startRendering more than once")); |
} |
- // If the context is not in the suspended state, reject the promise. |
- if (contextState() != AudioContextState::Suspended) { |
- return ScriptPromise::rejectWithDOMException( |
- scriptState, |
- DOMException::create( |
- InvalidStateError, |
- "cannot startRendering when an OfflineAudioContext is not in a suspended state")); |
- } |
- |
- m_completeResolver = ScriptPromiseResolver::create(scriptState); |
- |
- // Start rendering and return the promise. |
- ASSERT(!m_isRenderingStarted); |
- m_isRenderingStarted = true; |
- setContextState(Running); |
- destinationHandler().startRendering(); |
- |
- return m_completeResolver->promise(); |
+ m_offlineResolver = ScriptPromiseResolver::create(scriptState); |
+ startRendering(); |
+ return m_offlineResolver->promise(); |
} |
ScriptPromise OfflineAudioContext::closeContext(ScriptState* scriptState) |
@@ -225,202 +135,20 @@ |
ScriptPromise OfflineAudioContext::suspendContext(ScriptState* scriptState) |
{ |
- // This CANNOT be called on OfflineAudioContext; it is to implement the pure |
- // virtual interface from AbstractAudioContext. |
- RELEASE_ASSERT_NOT_REACHED(); |
- |
- return ScriptPromise(); |
-} |
- |
-ScriptPromise OfflineAudioContext::suspendContext(ScriptState* scriptState, double when) |
-{ |
- ASSERT(isMainThread()); |
- |
- RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); |
- ScriptPromise promise = resolver->promise(); |
- |
- // The render thread does not exist; reject the promise. |
- if (!destinationHandler().offlineRenderThread()) { |
- resolver->reject(DOMException::create(InvalidStateError, |
- "the rendering is already finished")); |
- return promise; |
- } |
- |
- // The specified suspend time is negative; reject the promise. |
- if (when < 0) { |
- resolver->reject(DOMException::create(InvalidStateError, |
- "negative suspend time (" + String::number(when) + ") is not allowed")); |
- return promise; |
- } |
- |
- // Quantize the suspend time to the render quantum boundary. |
- size_t quantizedFrame = destinationHandler().quantizeTimeToRenderQuantum(when); |
- |
- // The suspend time should be earlier than the total render frame. If the |
- // requested suspension time is equal to the total render frame, the promise |
- // will be rejected. |
- if (m_totalRenderFrames <= quantizedFrame) { |
- resolver->reject(DOMException::create(InvalidStateError, |
- "cannot schedule a suspend at frame " + String::number(quantizedFrame) + |
- " (" + String::number(when) + " seconds) " + |
- "because it is greater than or equal to the total render duration of " + |
- String::number(m_totalRenderFrames) + " frames")); |
- return promise; |
- } |
- |
- ScheduledSuspendContainer* suspendContainer = ScheduledSuspendContainer::create(when, quantizedFrame, resolver); |
- |
- // Validate the suspend and append if necessary on the render thread. |
- // Note that passing a raw pointer |suspendContainer| is safe here as well |
- // with the same reason in |resolvePendingSuspendPromises|. |
- destinationHandler().offlineRenderThread()->postTask(FROM_HERE, |
- threadSafeBind(&OfflineAudioContext::validateSuspendContainerOnRenderThread, this, AllowCrossThreadAccess(suspendContainer))); |
- |
- return promise; |
+ return ScriptPromise::rejectWithDOMException( |
+ scriptState, |
+ DOMException::create( |
+ InvalidAccessError, |
+ "cannot suspend an OfflineAudioContext")); |
} |
ScriptPromise OfflineAudioContext::resumeContext(ScriptState* scriptState) |
{ |
- ASSERT(isMainThread()); |
- |
- RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); |
- ScriptPromise promise = resolver->promise(); |
- |
- // If the context is not in a suspended state, reject the promise. |
- if (contextState() != AudioContextState::Suspended) { |
- resolver->reject(DOMException::create(InvalidStateError, |
- "cannot resume a context that is not suspended")); |
- return promise; |
- } |
- |
- // If the rendering has not started, reject the promise. |
- if (!m_isRenderingStarted) { |
- resolver->reject(DOMException::create(InvalidStateError, |
- "cannot resume a context that has not started")); |
- return promise; |
- } |
- |
- // If the context is suspended, resume rendering by setting the state to |
- // "Running." and calling startRendering(). Note that resuming is possible |
- // only after the rendering started. |
- setContextState(Running); |
- destinationHandler().startRendering(); |
- |
- // Resolve the promise immediately. |
- resolver->resolve(); |
- |
- return promise; |
-} |
- |
-OfflineAudioDestinationHandler& OfflineAudioContext::destinationHandler() |
-{ |
- return static_cast<OfflineAudioDestinationHandler&>(destination()->audioDestinationHandler()); |
-} |
- |
-void OfflineAudioContext::validateSuspendContainerOnRenderThread(ScheduledSuspendContainer* suspendContainer) |
-{ |
- ASSERT(!isMainThread()); |
- |
- bool shouldBeRejected = false; |
- |
- // The specified suspend time is in the past; reject the promise. We cannot |
- // reject the promise in here, so set the error message before posting the |
- // rejection task to the main thread. |
- if (suspendContainer->suspendFrame() < currentSampleFrame()) { |
- shouldBeRejected = true; |
- suspendContainer->setErrorMessageForRejection(InvalidStateError, |
- "cannot schedule a suspend at frame " + |
- String::number(suspendContainer->suspendFrame()) + " (" + |
- String::number(suspendContainer->suspendTime()) + |
- " seconds) because it is earlier than the current frame of " + |
- String::number(currentSampleFrame()) + " (" + |
- String::number(currentTime()) + " seconds)"); |
- } else if (m_scheduledSuspends.contains(suspendContainer->suspendFrame())) { |
- // If there is a duplicate suspension at the same quantized frame, |
- // reject the promise. The rejection of promise should happen in the |
- // main thread, so we post a task to it. Here we simply set the error |
- // message and post a task to the main thread. |
- shouldBeRejected = true; |
- suspendContainer->setErrorMessageForRejection(InvalidStateError, |
- "cannot schedule more than one suspend at frame " + |
- String::number(suspendContainer->suspendFrame()) + " (" + |
- String::number(suspendContainer->suspendTime()) + " seconds)"); |
- } |
- |
- // Reject the promise if necessary on the main thread. |
- // Note that passing a raw pointer |suspendContainer| is safe here as well |
- // with the same reason in |resolvePendingSuspendPromises|. |
- if (shouldBeRejected) { |
- Platform::current()->mainThread()->postTask(FROM_HERE, |
- threadSafeBind(&OfflineAudioContext::rejectSuspendContainerOnMainThread, this, AllowCrossThreadAccess(suspendContainer))); |
- return; |
- } |
- |
- // If the validation check passes, we can add the container safely here in |
- // the render thread. |
- m_scheduledSuspends.add(suspendContainer->suspendFrame(), suspendContainer); |
-} |
- |
-void OfflineAudioContext::rejectSuspendContainerOnMainThread(ScheduledSuspendContainer* suspendContainer) |
-{ |
- ASSERT(isMainThread()); |
- |
- suspendContainer->rejectPromise(); |
-} |
- |
-void OfflineAudioContext::resolveSuspendContainerOnMainThread(ScheduledSuspendContainer* suspendContainer) |
-{ |
- ASSERT(isMainThread()); |
- |
- // Suspend the context first. This will fire onstatechange event. |
- setContextState(Suspended); |
- |
- suspendContainer->resolvePromise(); |
-} |
- |
-ScheduledSuspendContainer::ScheduledSuspendContainer(double suspendTime, size_t suspendFrame, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver) |
- : m_suspendTime(suspendTime) |
- , m_suspendFrame(suspendFrame) |
- , m_resolver(resolver) |
-{ |
- ASSERT(isMainThread()); |
-} |
- |
-ScheduledSuspendContainer::~ScheduledSuspendContainer() |
-{ |
- ASSERT(isMainThread()); |
-} |
- |
-ScheduledSuspendContainer* ScheduledSuspendContainer::create(double suspendTime, size_t suspendFrame, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver) |
-{ |
- return new ScheduledSuspendContainer(suspendTime, suspendFrame, resolver); |
-} |
- |
-void ScheduledSuspendContainer::setErrorMessageForRejection(ExceptionCode errorCode, const String& errorMessage) |
-{ |
- ASSERT(!isMainThread()); |
- |
- m_errorCode = errorCode; |
- |
- // |errorMessage| is created on the render thread, but its actual usage is |
- // in the main thread. So we need to be thread-safe on this. |
- m_errorMessage = errorMessage.isolatedCopy(); |
-} |
- |
-void ScheduledSuspendContainer::resolvePromise() |
-{ |
- ASSERT(isMainThread()); |
- |
- m_resolver->resolve(); |
-} |
- |
-void ScheduledSuspendContainer::rejectPromise() |
-{ |
- ASSERT(isMainThread()); |
- ASSERT(m_errorCode); |
- ASSERT(m_errorMessage); |
- |
- m_resolver->reject(DOMException::create(m_errorCode, m_errorMessage)); |
+ return ScriptPromise::rejectWithDOMException( |
+ scriptState, |
+ DOMException::create( |
+ InvalidAccessError, |
+ "cannot resume an OfflineAudioContext")); |
} |
} // namespace blink |