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/OfflineAudioDestinationNode.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 47 matching lines @@
 
 OfflineAudioContext::OfflineAudioContext(Document* document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate)
     : AudioContext(document, numberOfChannels, numberOfFrames, sampleRate)
 {
 }
 
 OfflineAudioContext::~OfflineAudioContext()
 {
 }
 
+OfflineAudioContext::ScheduledSuspendContainer::ScheduledSuspendContainer(
+    double when, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+    : m_when(when)

[Raymond Toy, 2015/05/19 22:04:45]

Shouldn't this quantize the time to the rendering quantum start time?

+    , m_resolver(resolver)
+{
+}
+
+OfflineAudioContext::ScheduledSuspendContainer::~ScheduledSuspendContainer()
+{
+}
+
+DEFINE_TRACE(OfflineAudioContext::ScheduledSuspendContainer)
+{
+    visitor->trace(m_resolver);
+}
+
+PassOwnPtr<OfflineAudioContext::ScheduledSuspendContainer>
+OfflineAudioContext::ScheduledSuspendContainer::create(
+    double when, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+{
+    return adoptPtr(new ScheduledSuspendContainer(when, resolver));
+}
+
+bool OfflineAudioContext::ScheduledSuspendContainer::shouldBeSuspendedNow(double currentTime) const
+{
+    return m_when <= currentTime;
+}
+
+bool OfflineAudioContext::suspendIfNecessary()
+{
+    ASSERT(!isMainThread());
+
+    // Suspend if necessary and resolve the associated promise.
+    for (unsigned index = 0; index < m_scheduledSuspends.size(); ++index) {
+        if (m_scheduledSuspends.at(index)->shouldBeSuspendedNow(currentTime())) {
+            // Resolve scheduled suspend on the main thread.
+            Platform::current()->mainThread()->postTask(FROM_HERE,
+                threadSafeBind(
+                    &OfflineAudioContext::suspendAndResolveOnMainThread,
+                    this,
+                    index));
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool OfflineAudioContext::isSuspendScheduled() const
+{
+    return m_scheduledSuspends.size() > 0;
+}
+
 ScriptPromise OfflineAudioContext::startOfflineRendering(ScriptState* scriptState)
 {
+    ASSERT(isMainThread());
+    AutoLocker locker(this);
+
     // 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) {
         // 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();
+
+    // This calls AudioContext.startRendering(). It seems to be odd to go up the
+    // chain and call the parent's method, but the current OAC is basically a
+    // thin wrapper on AudioContext. (a container-like object.)
+    //
+    // If we decide to fix this structural issue completely, we have to touch
+    // AudioContext and AudioNode.
+    // startRendering();
+
+    destination()->audioDestinationHandler().startRendering();
+    setContextState(Running);
+
     return m_offlineResolver->promise();
 }
 
+ScriptPromise OfflineAudioContext::suspendOfflineRendering(ScriptState* scriptState, double when)
+{
+    ASSERT(isMainThread());
+    AutoLocker locker(this);
+
+    // suspendTime should be greater than currentTime. Note that this is called
+    // from the main thread, so the currentTime will be one rendering quantum
+    // behind the actual current time.
+    if (currentTime() < when) {
+        RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+        ScriptPromise promise = resolver->promise();
+        m_scheduledSuspends.append(ScheduledSuspendContainer::create(when, resolver));
+        return promise;
+    }
+
+    // If suspendTime is already passed, throw an exception.
+    return ScriptPromise::rejectWithDOMException(
+        scriptState,
+        DOMException::create(
+            InvalidStateError,
+            "cannot schedule a suspend in the past"));
+}
+
+ScriptPromise OfflineAudioContext::resumeOfflineRendering(ScriptState* scriptState)
+{
+    ASSERT(isMainThread());
+    AutoLocker locker(this);
+
+    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+    m_resumeResolvers.append(resolver);

[Raymond Toy, 2015/05/19 22:04:45]

Not sure, but I think you can resolve the promise here immediately. It's not
like the online context where we want to wait for the HW to restart.  We're
already restarted as soon as startRendering() is called, right?

Allows us to get rid of the vector.

Or is it really needed in some situation?

[hongchan, 2015/05/20 22:09:40]

I agree. This was just to make the structure symmetric. Will try the new idea in
PS4.

+
+    // Calling startRendering() in OfflineAudioDestinationHandler.
+    destination()->audioDestinationHandler().startRendering();
+    setContextState(Running);
+
+    return promise;
+}
+
+void OfflineAudioContext::suspendAndResolveOnMainThread(unsigned index)
+{
+    ASSERT(isMainThread());
+    AutoLocker locker(this);
+
+    setContextState(Suspended);
+
+    m_scheduledSuspends.at(index)->resolver()->resolve();
+
+    // TO FIX: does this automatically re-arrange the rest of vector?
+    m_scheduledSuspends.remove(index);
+}
+
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)