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 d3488419e947e373d50f13cb105be0fb0604d178..78898805b39f3a2832faccc440f82e620e875a94 100644
--- a/Source/modules/webaudio/OfflineAudioContext.cpp
+++ b/Source/modules/webaudio/OfflineAudioContext.cpp
@@ -31,7 +31,13 @@
 #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 {
 
@@ -92,6 +98,8 @@ OfflineAudioContext* OfflineAudioContext::create(ExecutionContext* context, unsi
 
 OfflineAudioContext::OfflineAudioContext(Document* document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate)
     : AudioContext(document, numberOfChannels, numberOfFrames, sampleRate)
+    , m_isRenderingStarted(false)
+    , m_totalRenderFrames(numberOfFrames)
 {
 }
 
@@ -99,8 +107,67 @@ OfflineAudioContext::~OfflineAudioContext()
 {
 }
 
+DEFINE_TRACE(OfflineAudioContext)
+{
+    visitor->trace(m_completeResolver);
+    AudioContext::trace(visitor);
+}
+
+bool OfflineAudioContext::shouldSuspendNow()
+{
+    ASSERT(!isMainThread());
+
+    // If there is any scheduled suspend at |currentSampleFrame|, the context
+    // should be suspended.
+    if (m_scheduledSuspends.isEmpty() || !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 (m_scheduledSuspends.isEmpty() || it == m_scheduledSuspends.end())
+        return;
+
+    RefPtr<ScheduledSuspendContainer> suspendContainer = it->value;
+    m_scheduledSuspends.remove(it);
+    Platform::current()->mainThread()->postTask(FROM_HERE,
+        threadSafeBind(&OfflineAudioContext::resolvePendingSuspendPromisesOnMainThread, this, suspendContainer.release()));
+}
+
+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);

[haraken, 2015/06/30 07:41:51]

If executionContext() is already gone, is it guaranteed that the resolver has
been already rejected? Otherwise, the resolver will leak memory.

[hongchan, 2015/06/30 18:52:10]

I agree. The resolver should be rejected when the execution context is gone.

+    }
+}
+
 ScriptPromise OfflineAudioContext::startOfflineRendering(ScriptState* scriptState)
 {
+    ASSERT(isMainThread());
+
     // Calling close() on an OfflineAudioContext is not supported/allowed,
     // but it might well have been stopped by its execution context.
     if (isContextClosed()) {
@@ -111,7 +178,7 @@ ScriptPromise OfflineAudioContext::startOfflineRendering(ScriptState* scriptStat
                 "cannot call startRendering on an OfflineAudioContext in a stopped state."));
     }
 
-    if (m_offlineResolver) {
+    if (m_completeResolver) {
         // Can't call startRendering more than once.  Return a rejected promise now.
         return ScriptPromise::rejectWithDOMException(
             scriptState,
@@ -120,9 +187,168 @@ ScriptPromise OfflineAudioContext::startOfflineRendering(ScriptState* scriptStat
                 "cannot call startRendering more than once"));
     }
 
-    m_offlineResolver = ScriptPromiseResolver::create(scriptState);
-    startRendering();
-    return m_offlineResolver->promise();
+    // 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.
+    m_isRenderingStarted = true;

[haraken, 2015/06/30 07:41:51]

Shall we add ASSERT(!m_isRenderingStarted)?

[hongchan, 2015/06/30 18:52:10]

Done.

+    setContextState(Running);
+    destination()->audioDestinationHandler().startRendering();
+
+    return m_completeResolver->promise();
+}
+
+ScriptPromise OfflineAudioContext::suspendOfflineRendering(ScriptState* scriptState, double when)
+{
+    ASSERT(isMainThread());
+    ASSERT(destination()->audioDestinationHandler().offlineRenderThread());

[haraken, 2015/06/30 07:41:51]

How is it guaranteed that the offline render thread still exists? Isn't it
possible that the render thread has already finished?

[hongchan, 2015/06/30 18:52:10]

Good point. I need to check if the render thread does exist here.

+
+    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->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 = destination()->audioDestinationHandler().quantizeTimeToRenderQuantum(when);
+
+    // The specified suspend time is in the past, reject the promise.
+    if (quantizedFrame < currentSampleFrame()) {

[haraken, 2015/06/30 07:41:51]

There is a delay between this check (conducted by the main thread) and the
timing where the suspend container gets added to the map by the render thread.
Isn't it possible that the render thread ends up with adding a stale suspend
container to the map?

[hongchan, 2015/06/30 18:52:10]

Moving this timing check into 'checkDuplicateSuspend()' and it posts the
rejection to the main thread if necessary. I believe that will solve the delay
issue.

+        resolver->reject(DOMException::create(InvalidStateError,
+            "cannot schedule a suspend at frame " + String::number(quantizedFrame) +
+            " (" + String::number(when) + " seconds) because it is earlier than the current frame of " +
+            String::number(currentSampleFrame())));
+        return promise;
+    }
+
+    // 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;
+    }
+
+    RefPtr<ScheduledSuspendContainer> suspendContainer = ScheduledSuspendContainer::create(when, quantizedFrame, resolver);
+
+    // Validate the suspend and append if necessary on the render thread.
+    destination()->audioDestinationHandler().offlineRenderThread()->postTask(FROM_HERE,
+        threadSafeBind(&OfflineAudioContext::checkDuplicateSuspend, this, suspendContainer));
+
+    return promise;
+}
+
+ScriptPromise OfflineAudioContext::resumeOfflineRendering(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);
+    destination()->audioDestinationHandler().startRendering();
+
+    // Resolve the promise immediately.
+    resolver->resolve();
+
+    return promise;
+}
+
+void OfflineAudioContext::checkDuplicateSuspend(PassRefPtr<ScheduledSuspendContainer> suspendContainer)
+{
+    ASSERT(!isMainThread());
+
+    // 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.
+    if (m_scheduledSuspends.contains(suspendContainer->suspendFrame())) {
+        Platform::current()->mainThread()->postTask(FROM_HERE,
+            threadSafeBind(&OfflineAudioContext::rejectSuspendPromiseOnMainThread, this, suspendContainer));
+        return;
+    }
+
+    // If the duplicate check passes, we can add the container safely here in
+    // the render thread.
+    m_scheduledSuspends.add(suspendContainer->suspendFrame(), suspendContainer);
+}
+
+void OfflineAudioContext::rejectSuspendPromiseOnMainThread(PassRefPtr<ScheduledSuspendContainer> suspendContainer)
+{
+    ASSERT(isMainThread());
+
+    suspendContainer->resolver()->reject(DOMException::create(InvalidStateError,
+        "cannot schedule more than one suspend at frame " +
+        String::number(suspendContainer->suspendFrame()) + " (" +
+        String::number(suspendContainer->suspendTime()) + " seconds)"));
+}
+
+void OfflineAudioContext::resolvePendingSuspendPromisesOnMainThread(PassRefPtr<ScheduledSuspendContainer> suspendContainer)
+{
+    ASSERT(isMainThread());
+    AutoLocker locker(this);

[haraken, 2015/06/30 07:41:51]

I didn't follow all the discussions about the lock, but do we really need this
lock? What is this lock protecting?

[hongchan, 2015/06/30 18:52:10]

I was following the pattern from
AudioContext::resolvePromisesForResumeOnMainThread() and yhirano@ wanted to ask
rtoy@'s opinion on this.

However, I am happy to remove the lock if it is redundant here.

+
+    // Suspend the context first. This will fire onstatechange event.
+    setContextState(Suspended);
+
+    suspendContainer->resolver()->resolve();
+}
+
+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());
+}
+
+PassRefPtr<ScheduledSuspendContainer> ScheduledSuspendContainer::create(double suspendTime, size_t suspendFrame, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+{
+    return adoptRef(new ScheduledSuspendContainer(suspendTime, suspendFrame, resolver));
+}
+
+bool ScheduledSuspendContainer::shouldSuspendAtFrame(size_t whenFrame) const
+{
+    if (m_suspendFrame != whenFrame)

[haraken, 2015/06/30 07:41:50]

Just to confirm: This is not m_suspendFrame < whenFrame, but m_suspendFrame !=
whenFrame?

[hongchan, 2015/06/30 18:52:10]

Yes, I wanted to be specific about this. If we allow |m_suspendFrame <
whenFrame|, the suspension will  be performed even after it misses the exact
moment. This is not the real-time audio rendering, so having the higher level of
accuracy is important. Also all the frame numbers are quantized by the render
quantum size, so there should be no room for errors.

Actually ASSERT(whenFrame <= m_suspendFrame) might be nice to add here. Any
scheduled suspension should be resolved and removed at its exact timing.

+        return false;
+
+    return true;
 }
 
 } // namespace blink