Implement suspend() and resume() for OfflineAudioContext

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 13 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 "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 {
 
 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,
             "Workers are not supported.");
@@ skipping 40 matching lines @@
             + ", " + String::number(sampleRate)
             + ")");
     }
 
     audioContext->suspendIfNeeded();
     return audioContext;
 }
 
 OfflineAudioContext::OfflineAudioContext(Document* document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate)
     : AudioContext(document, numberOfChannels, numberOfFrames, sampleRate)
+    , m_isRenderingStarted(false)
+    , m_isResolvingSuspendPromise(false)
+    , m_totalRenderFrames(numberOfFrames)
 {
 }
 
 OfflineAudioContext::~OfflineAudioContext()
 {
 }
 
+DEFINE_TRACE(OfflineAudioContext)
+{
+    visitor->trace(m_scheduledSuspends);

[hongchan, 2015/06/24 21:14:12]

This gives me a compile error:

./../third_party/WebKit/Source/wtf/HashTable.h:1340:41: error: no matching
member function for call to 'trace'
                    Allocator::template trace<VisitorDispatcher, ValueType,
Traits>(visitor, *element);
                   
~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../../third_party/WebKit/Source/wtf/HashMap.h:157:56: note: in instantiation of
function template specialization 'WTF::HashTable<unsigned long,
WTF::KeyValuePair<unsigned long, WTF::RefPtr<blink::ScheduledSuspendContainer>
>, WTF::KeyValuePairKeyExtractor, WTF::IntHash<unsigned long>,
WTF::HashMapValueTraits<WTF::HashTraits<unsigned long>,
WTF::HashTraits<WTF::RefPtr<blink::ScheduledSuspendContainer> > >,
WTF::HashTraits<unsigned long>, WTF::DefaultAllocator>::trace<blink::Visitor *>'
requested here
        void trace(VisitorDispatcher visitor) { m_impl.trace(visitor); }
                                                       ^
../../third_party/WebKit/Source/platform/heap/TraceTraits.h:164:32: note: in
instantiation of function template specialization 'WTF::HashMap<unsigned long,
WTF::RefPtr<blink::ScheduledSuspendContainer>, WTF::IntHash<unsigned long>,
WTF::HashTraits<unsigned long>,
WTF::HashTraits<WTF::RefPtr<blink::ScheduledSuspendContainer> >,
WTF::DefaultAllocator>::trace<blink::Visitor *>' requested here
        static_cast<T*>(self)->trace(visitor);
                               ^
../../third_party/WebKit/Source/platform/heap/Visitor.h:222:24: note: in
instantiation of member function 'blink::TraceTrait<WTF::HashMap<unsigned long,
WTF::RefPtr<blink::ScheduledSuspendContainer>, WTF::IntHash<unsigned long>,
WTF::HashTraits<unsigned long>,
WTF::HashTraits<WTF::RefPtr<blink::ScheduledSuspendContainer> >,
WTF::DefaultAllocator> >::trace' requested here
        TraceTrait<T>::trace(Derived::fromHelper(this), &const_cast<T&>(t));
                       ^
../../third_party/WebKit/Source/modules/webaudio/OfflineAudioContext.cpp:113:14:
note: in instantiation of function template specialization
'blink::VisitorHelper<blink::Visitor>::trace<WTF::HashMap<unsigned long,
WTF::RefPtr<blink::ScheduledSuspendContainer>, WTF::IntHash<unsigned long>,
WTF::HashTraits<unsigned long>,
WTF::HashTraits<WTF::RefPtr<blink::ScheduledSuspendContainer> >,
WTF::DefaultAllocator> >' requested here
    visitor->trace(m_scheduledSuspends);
             ^
../../third_party/WebKit/Source/modules/webaudio/OfflineAudioContext.cpp:111:1:
note: in instantiation of function template specialization
'blink::OfflineAudioContext::traceImpl<blink::Visitor *>' requested here
DEFINE_TRACE(OfflineAudioContext)
^
../../third_party/WebKit/Source/platform/heap/Visitor.h:103:39: note: expanded
from macro 'DEFINE_TRACE'
    void T::trace(Visitor* visitor) { traceImpl(visitor); }                    \
                                      ^
../../third_party/WebKit/Source/wtf/DefaultAllocator.h:170:17: note: candidate
template ignored: invalid explicitly-specified argument for template parameter
'Traits'
    static void trace(...)

Not sure what this is about.

[haraken, 2015/06/24 23:25:57]

m_scheduledSuspends is not a HashMap of Oilpan. You shouldn't trace it.

[hongchan, 2015/06/25 23:34:13]

Done.

+    visitor->trace(m_completeResolver);
+    AudioContext::trace(visitor);
+}
+
+bool OfflineAudioContext::shouldSuspendNow()
+{
+    ASSERT(!isMainThread());
+
+    fprintf(stderr, "shouldSuspendNow\n");
+
+    // If there is any scheduled suspend at |currentSampleFrame|, the context
+    // should be suspended.
+    if (m_scheduledSuspends.contains(currentSampleFrame()))
+        return true;
+
+    return false;
+}
+
+void OfflineAudioContext::resolvePendingSuspendPromises()
+{
+    ASSERT(!isMainThread());
+
+    fprintf(stderr, "resolvePendingSuspendPromises\n");
+
+    if (!m_isResolvingSuspendPromise || m_scheduledSuspends.isEmpty())
+        return;
+
+    size_t nowFrame = currentSampleFrame();
+
+    SuspendContainerMap::iterator it = m_scheduledSuspends.find(nowFrame);
+    if (it == m_scheduledSuspends.end())
+        return;
+
+    RefPtrWillBeRawPtr<ScheduledSuspendContainer> suspendContainer = it->value;

[yhirano, 2015/06/25 04:00:53]

This should be just RefPtr.

[hongchan, 2015/06/25 23:34:13]

Done.

+    Platform::current()->mainThread()->postTask(FROM_HERE,
+        threadSafeBind(&OfflineAudioContext::resolvePendingSuspendPromisesOnMainThread, this, suspendContainer));

[yhirano, 2015/06/25 04:00:53]

suspendContainer.release()

[hongchan, 2015/06/25 23:34:13]

Done.

+    m_scheduledSuspends.remove(nowFrame);

[yhirano, 2015/06/25 04:00:52]

Please move this statement to L148.

[yhirano, 2015/06/25 04:00:53]

[optional] remove(it) may be more straightforward?

[hongchan, 2015/06/25 23:34:13]

Done and 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);
+    }
+}
+
 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()) {
         return ScriptPromise::rejectWithDOMException(
             scriptState,
             DOMException::create(
                 InvalidStateError,
                 "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,
             DOMException::create(
                 InvalidStateError,
                 "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;
+    setContextState(Running);
+    destination()->audioDestinationHandler().startRendering();
+
+    return m_completeResolver->promise();
+}
+
+ScriptPromise OfflineAudioContext::suspendOfflineRendering(ScriptState* scriptState, double when)
+{
+    ASSERT(isMainThread());
+    ASSERT(destination()->audioDestinationHandler().offlineRenderThread());
+
+    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 rendering block boundary.
+    size_t quantizedFrame = destination()->audioDestinationHandler().quantizeTimeToRenderQuantum(when);
+
+    // The specified suspend time is in the past, reject the promise.
+    if (quantizedFrame < currentSampleFrame()) {
+        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;
+    }
+
+    ScheduledSuspendContainer* suspendContainer = ScheduledSuspendContainer::create(when, quantizedFrame, resolver);

[yhirano, 2015/06/25 04:00:52]

RefPtr<ScheduledSuspendContainer> suspendContainer = ...;

[hongchan, 2015/06/25 23:34:13]

Done.

+
+    // 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(ScheduledSuspendContainer* suspendContainer)

[yhirano, 2015/06/25 04:00:53]

PassRefPtr<ScheduledSuspendContainer>

[hongchan, 2015/06/25 23:34:13]

Done.

+{
+    ASSERT(!isMainThread());
+
+    fprintf(stderr, "checkDuplicateSuspend\n");
+
+    // If there is a duplicate suspension at the same quantize 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));
+    }
+
+    // If duplicate check passes, we can add the container safely here in the
+    // render thread.
+    RefPtr<ScheduledSuspendContainer> adoptedContainer = adoptRef(suspendContainer);

[yhirano, 2015/06/25 04:00:53]

You should not use adoptRef here.

[hongchan, 2015/06/25 23:34:13]

Done.

+    m_scheduledSuspends.set(suspendContainer->suspendFrame(), adoptedContainer);

[hongchan, 2015/06/24 21:14:12]

This might be the problematic part. Since the |suspendContainer| is a raw
pointer, I converted it back to RefPtr before adding it to the hashmap. Please
let me know if this does not look good.

+}
+
+void OfflineAudioContext::rejectSuspendPromiseOnMainThread(ScheduledSuspendContainer* suspendContainer)

[yhirano, 2015/06/25 04:00:52]

PassRefPtr<ScheduledSuspendContainer>

[hongchan, 2015/06/25 23:34:13]

Done.

+{
+    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(ScheduledSuspendContainer* suspendContainer)

[yhirano, 2015/06/25 04:00:53]

PassRefPtr<ScheduledSuspendContainer>

[hongchan, 2015/06/25 23:34:13]

Done.

+{
+    ASSERT(isMainThread());
+    AutoLocker locker(this);
+
+    // Suspend the context first. This will fire onstatechange event.
+    setContextState(Suspended);
+
+    suspendContainer->resolver()->resolve();
+    m_isResolvingSuspendPromise = false;
+}
+
+ScheduledSuspendContainer::ScheduledSuspendContainer(
+    double suspendTime, size_t suspendFrame, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+    : m_suspendTime(suspendTime)
+    , m_suspendFrame(suspendFrame)
+    , m_resolver(resolver)
+    , m_isPending(false)
+{

[yhirano, 2015/06/25 04:00:53]

ASSERT(isMainThread);

[hongchan, 2015/06/25 23:34:13]

Done.

+}
+
+ScheduledSuspendContainer::~ScheduledSuspendContainer()
+{

[yhirano, 2015/06/25 04:00:53]

ASSERT(isMainThread);

[hongchan, 2015/06/25 23:34:13]

Done.

+}
+
+DEFINE_TRACE(ScheduledSuspendContainer)

[yhirano, 2015/06/25 04:00:53]

No trace is needed.

[hongchan, 2015/06/25 23:34:13]

Done.

+{
+    visitor->trace(m_resolver);
+}
+
+ScheduledSuspendContainer* ScheduledSuspendContainer::create(
+    double suspendTime, size_t suspendFrame, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+{
+    return new ScheduledSuspendContainer(suspendTime, suspendFrame, resolver);
+}
+
+bool ScheduledSuspendContainer::shouldSuspendAtFrame(size_t whenFrame) const
+{
+    if (m_suspendFrame != whenFrame)
+        return false;
+
+    return true;
+}
+
+bool ScheduledSuspendContainer::isPending() const
+{
+    return m_isPending;
+}
+
+void ScheduledSuspendContainer::markAsPending()
+{
+    m_isPending = true;
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)