Implement suspend() and resume() for OfflineAudioContext

third_party/WebKit/Source/modules/webaudio/OfflineAudioContext.cpp

 /*
  * Copyright (C) 2012, 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 14 matching lines @@
 #include "config.h"
 #if ENABLE(WEB_AUDIO)
 #include "modules/webaudio/OfflineAudioContext.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
+#include "modules/webaudio/DeferredTaskHandler.h"
+#include "modules/webaudio/OfflineAudioCompletionEvent.h"
+#include "modules/webaudio/OfflineAudioDestinationNode.h"
+
 #include "platform/audio/AudioUtilities.h"
 
 namespace blink {
 
 OfflineAudioContext* OfflineAudioContext::create(ExecutionContext* context, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate, ExceptionState& exceptionState)
 {
     // FIXME: add support for workers.
     if (!context || !context->isDocument()) {
         exceptionState.throwDOMException(
             NotSupportedError,
@@ skipping 24 matching lines @@
     if (!AudioUtilities::isValidAudioBufferSampleRate(sampleRate)) {
         exceptionState.throwDOMException(
             IndexSizeError,
             ExceptionMessages::indexOutsideRange(
                 "sampleRate", sampleRate,
                 AudioUtilities::minAudioBufferSampleRate(), ExceptionMessages::InclusiveBound,
                 AudioUtilities::maxAudioBufferSampleRate(), ExceptionMessages::InclusiveBound));
         return nullptr;
     }
 
-    OfflineAudioContext* audioContext = new OfflineAudioContext(document, numberOfChannels, numberOfFrames, sampleRate);
+    OfflineAudioContext* audioContext = new OfflineAudioContext(document, numberOfChannels, numberOfFrames, sampleRate, exceptionState);
 
     if (!audioContext->destination()) {
         exceptionState.throwDOMException(
             NotSupportedError,
             "OfflineAudioContext(" + String::number(numberOfChannels)
             + ", " + String::number(numberOfFrames)
             + ", " + String::number(sampleRate)
             + ")");
     }
 
     audioContext->suspendIfNeeded();
     return audioContext;
 }
 
-OfflineAudioContext::OfflineAudioContext(Document* document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate)
+OfflineAudioContext::OfflineAudioContext(Document* document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate, ExceptionState& exceptionState)
     : AbstractAudioContext(document, numberOfChannels, numberOfFrames, sampleRate)
+    , m_isRenderingStarted(false)
+    , m_totalRenderFrames(numberOfFrames)
 {
+    // Create a new destination for offline rendering.
+    m_renderTarget = AudioBuffer::create(numberOfChannels, numberOfFrames, sampleRate);
+
+    // Throw an exception if the render target is not ready.
+    if (!m_renderTarget) {
+        exceptionState.throwRangeError(ExceptionMessages::failedToConstruct(
+            "AudioBuffer",
+            "failed to create a target buffer for offline rendering. (" +
+            String::number(numberOfChannels) + ", " + String::number(numberOfFrames) +
+            ")"));

[Raymond Toy, 2015/10/22 20:27:17]

Nit: If you're going to do this, I would propose this:

"failed to create OfflineAudioContext(nc, nf, rate)"

What you have has little context on what the numbers mean.  Instead of this, you
can explicitly say something like "offline rendering of nc channels of nf
frames"

[hongchan, 2015/10/22 21:05:03]

Done. I took your first solution.

+    }
+
+    if (m_renderTarget.get())
+        m_destinationNode = OfflineAudioDestinationNode::create(this, m_renderTarget.get());
+
+    initialize();
 }
 
 OfflineAudioContext::~OfflineAudioContext()
 {
 }
 
+DEFINE_TRACE(OfflineAudioContext)
+{
+    visitor->trace(m_renderTarget);
+    visitor->trace(m_completeResolver);
+    visitor->trace(m_scheduledSuspends);
+    AbstractAudioContext::trace(visitor);
+}
+
 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.
+    //
+    // See: crbug.com/435867
     if (isContextClosed()) {
         return ScriptPromise::rejectWithDOMException(
             scriptState,
             DOMException::create(
                 InvalidStateError,
                 "cannot call startRendering on an OfflineAudioContext in a stopped state."));
     }
 
-    if (m_offlineResolver) {
-        // Can't call startRendering more than once.  Return a rejected promise now.
+    // If the context is not in the suspended state (i.e. running), reject the promise.
+    if (contextState() != AudioContextState::Suspended) {
         return ScriptPromise::rejectWithDOMException(
             scriptState,
             DOMException::create(
+                InvalidStateError,
+                "cannot startRendering when an OfflineAudioContext is " + state()));
+    }
+
+    // Can't call startRendering more than once.  Return a rejected promise now.
+    if (m_isRenderingStarted) {
+        return ScriptPromise::rejectWithDOMException(
+            scriptState,
+            DOMException::create(
                 InvalidStateError,
                 "cannot call startRendering more than once"));
     }
 
-    m_offlineResolver = ScriptPromiseResolver::create(scriptState);
-    startRendering();
-    return m_offlineResolver->promise();
+    ASSERT(!m_isRenderingStarted);
+
+    m_completeResolver = ScriptPromiseResolver::create(scriptState);
+
+    // Start rendering and return the promise.
+    m_isRenderingStarted = true;
+    setContextState(Running);
+    destinationHandler().startRendering();
+
+    return m_completeResolver->promise();
 }
 
 ScriptPromise OfflineAudioContext::closeContext(ScriptState* scriptState)
 {
     return ScriptPromise::rejectWithDOMException(
         scriptState,
-        DOMException::create(InvalidAccessError, "cannot close an OfflineAudioContext."));
-}
-
-ScriptPromise OfflineAudioContext::suspendContext(ScriptState* scriptState)
-{
-    return ScriptPromise::rejectWithDOMException(
-        scriptState,
         DOMException::create(
             InvalidAccessError,
-            "cannot suspend an OfflineAudioContext"));
+            "cannot close an OfflineAudioContext."));
+}
+
+ScriptPromise OfflineAudioContext::suspendContext(ScriptState* scriptState, double when)
+{
+    ASSERT(isMainThread());
+
+    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 (to the lower boundary) the suspend time by the render quantum.
+    size_t frame = when * sampleRate();
+    frame -= frame % destinationHandler().renderQuantumFrames();
+
+    // 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 <= frame) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "cannot schedule a suspend at frame " + String::number(frame) +
+            " (" + String::number(when) + " seconds) " +
+            "because it is greater than or equal to the total render duration of " +
+            String::number(m_totalRenderFrames) + " frames"));
+        return promise;
+    }
+
+    // The specified suspend time is in the past; reject the promise.
+    if (frame < currentSampleFrame()) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "cannot schedule a suspend at frame " +
+            String::number(frame) + " (" + String::number(when) +
+            " seconds) because it is earlier than the current frame of " +
+            String::number(currentSampleFrame()) + " (" +
+            String::number(currentTime()) + " seconds)"));
+        return promise;
+    }
+
+    // If there is a duplicate suspension at the same quantized frame,
+    // reject the promise.
+    if (m_scheduledSuspends.contains(frame)) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "cannot schedule more than one suspend at frame " +
+            String::number(frame) + " (" +
+            String::number(when) + " seconds)"));
+        return promise;
+    }
+
+    // Wait until the suspend map is available for the insertion. Here we should
+    // use AutoLocker because it locks the graph from the main thread.
+    AutoLocker locker(this);
+
+    m_scheduledSuspends.add(frame, resolver);
+
+    return promise;
 }
 
 ScriptPromise OfflineAudioContext::resumeContext(ScriptState* scriptState)
 {
+    ASSERT(isMainThread());
+
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+
+    // If the rendering has not started, reject the promise.
+    if (!m_isRenderingStarted) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "cannot resume an offline context that has not started"));
+        return promise;
+    }
+
+    // If the context is not in a suspended or closed state, reject the promise.
+    //
+    // TODO(hongchan): there is a conflict in the spec regarding resuming a
+    // running context. Per the current spec, the implementation here rejects
+    // the promise for resuming a running context. See crbug.com/545686
+    if (contextState() != AudioContextState::Suspended) {
+        resolver->reject(DOMException::create(InvalidStateError,
+            "cannot resume an offline context that is " + state()));
+        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;
+}
+
+ScriptPromise OfflineAudioContext::suspendContext(ScriptState* scriptState)
+{
+    // This CANNOT be called on OfflineAudioContext; this is only to implement
+    // the pure virtual interface from AbstractAudioContext.
+    RELEASE_ASSERT_NOT_REACHED();
+
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(
-            InvalidAccessError,
-            "cannot resume an OfflineAudioContext"));
+            InvalidStateError,
+            "cannot suspend offline audio context without the specified time."));
+}
+
+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"));
+    }
+}
+
+bool OfflineAudioContext::handlePreOfflineRenderTasks()
+{
+    ASSERT(isAudioThread());
+
+    // OfflineGraphAutoLocker here locks the audio graph for this scope. Note
+    // that this locker does not use tryLock() inside because the timing of
+    // suspension MUST NOT be delayed.
+    OfflineGraphAutoLocker locker(this);
+
+    deferredTaskHandler().handleDeferredTasks();
+    handleStoppableSourceNodes();
+
+    return shouldSuspend();
+}
+
+void OfflineAudioContext::handlePostOfflineRenderTasks()
+{
+    ASSERT(isAudioThread());
+
+    // OfflineGraphAutoLocker here locks the audio graph for the same reason
+    // above in |handlePreOfflineRenderTasks|.
+    OfflineGraphAutoLocker locker(this);
+
+    deferredTaskHandler().breakConnections();
+    releaseFinishedSourceNodes();
+    deferredTaskHandler().handleDeferredTasks();
+    deferredTaskHandler().requestToDeleteHandlersOnMainThread();
+}
+
+
+OfflineAudioDestinationHandler& OfflineAudioContext::destinationHandler()
+{
+    return static_cast<OfflineAudioDestinationHandler&>(destination()->audioDestinationHandler());
+}
+
+void OfflineAudioContext::resolveSuspendOnMainThread(size_t frame)
+{
+    ASSERT(isMainThread());
+
+    // Suspend the context first. This will fire onstatechange event.
+    setContextState(Suspended);
+
+    ASSERT(m_scheduledSuspends.contains(frame));
+
+    // Wait until the suspend map is available for the removal.
+    AutoLocker locker(this);
+
+    SuspendMap::iterator it = m_scheduledSuspends.find(frame);
+    it->value->resolve();
+
+    m_scheduledSuspends.remove(it);
+}
+
+bool OfflineAudioContext::shouldSuspend()
+{
+    ASSERT(isAudioThread());
+
+    if (m_scheduledSuspends.contains(currentSampleFrame()))
+        return true;
+
+    return false;
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)