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..4dcfa3eb38f8b61e75fb0dc54607028679ec85b3 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,19 +107,82 @@ 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.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);
+    Platform::current()->mainThread()->postTask(FROM_HERE,
+        threadSafeBind(&OfflineAudioContext::resolveSuspendContainerOnMainThread, this, suspendContainer));

[hongchan, 2015/07/08 17:47:32]

haraken@

Now |suspendContainer| being created on the render thread and passed to the main
thread for promise resolution. Calling the resolve method should be thread-safe
with |threadSafeBind()| whereas the |suspendContainer| is not. I am trying to
find a clean/elegant way of solving this without bringing too much RefPtr stuff
into here. Do you have any suggestion?

FYI, This is the error I am getting from |resolvePendingSuspendPromises()|:

../../third_party/WebKit/Source/platform/CrossThreadCopier.h:171:60: error:
implicit instantiation of undefined template
'blink::CrossThreadCopierBase<false, false, false,
blink::ScheduledSuspendContainer *>'
    template<typename T> struct CrossThreadCopier : public
CrossThreadCopierBase<WTF::IsConvertibleToInteger<T>::value,
                                                           ^
../../third_party/WebKit/Source/platform/ThreadSafeFunctional.h:52:9: note: in
instantiation of template class
'blink::CrossThreadCopier<blink::ScheduledSuspendContainer *>' requested here
        CrossThreadCopier<P2>::copy(parameter2));
        ^
../../third_party/WebKit/Source/modules/webaudio/OfflineAudioContext.cpp:141:9:
note: in instantiation of function template specialization
'blink::threadSafeBind<, void
(blink::OfflineAudioContext::*)(blink::ScheduledSuspendContainer *),
blink::OfflineAudioContext *, blink::ScheduledSuspendContainer *>' requested
here
       
threadSafeBind(&OfflineAudioContext::resolveSuspendContainerOnMainThread, this,
suspendContainer));
        ^
../../third_party/WebKit/Source/platform/CrossThreadCopier.h:64:116: note:
template is declared here
    template<bool isConvertibleToInteger, bool isThreadSafeRefCounted, bool
isGarbageCollected, typename T> struct CrossThreadCopierBase;
                                                                                
                                  ^
1 error generated.

[hiroshige, 2015/07/09 05:20:15]

IIUC,
- |suspendContainer| is created/managed/destructed on the main thread, and
- |suspendContainer| is guaranteed to be alive until the task is executed by
code somewhere else
and thus it is thread-safe to pass the raw pointer to the main thread.

If so, passing |AllowCrossThreadAccess(suspendContainer)| to threadSafeBind()
will resolve the compiler error.
(Functionally |suspendContainer| is just passed as the raw pointer as-is.
AllowCrossThreadAccess() just tells threadSafeBind() to allow passing the
pointer.)

Please add a brief comment describing why passing the raw pointer is
thread-safe.

[hongchan, 2015/07/09 17:08:37]

Done.

+}
+
+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 stopped by its execution context.
+    // but it might well have been closed by its execution context.
     if (isContextClosed()) {
         return ScriptPromise::rejectWithDOMException(
             scriptState,
             DOMException::create(
                 InvalidStateError,
-                "cannot call startRendering on an OfflineAudioContext in a stopped state."));
+                "cannot call startRendering on an OfflineAudioContext in a closed 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 +191,205 @@ 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.
+    ASSERT(!m_isRenderingStarted);
+    m_isRenderingStarted = true;
+    setContextState(Running);
+    destination()->audioDestinationHandler().startRendering();
+
+    return m_completeResolver->promise();
+}
+
+ScriptPromise OfflineAudioContext::suspendOfflineRendering(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 (!destination()->audioDestinationHandler().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 = destination()->audioDestinationHandler().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.
+    destination()->audioDestinationHandler().offlineRenderThread()->postTask(FROM_HERE,
+        threadSafeBind(&OfflineAudioContext::validateSuspendContainerOnRenderThread, 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::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()));
+    } 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.
+    if (shouldBeRejected) {
+        Platform::current()->mainThread()->postTask(FROM_HERE,
+            threadSafeBind(&OfflineAudioContext::rejectSuspendContainerOnMainThread, this, 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));
 }
 
 } // namespace blink