Revert of Implement suspend() and resume() for OfflineAudioContext

Source/modules/webaudio/OfflineAudioContext.cpp

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