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 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_isSuspendScheduled(false)
+    , m_suspendTime(-0.0)

[Raymond Toy, 2015/05/13 17:16:08]

Why -0.0?  This probably won't do what you think it does.

[hongchan, 2015/05/13 17:30:53]

What would be the proper 'null' value for this case? Actually it really doesn't
matter since we have another flag for the validity of suspend time. Just want to
ask your opinion.

 {
 }
 
 OfflineAudioContext::~OfflineAudioContext()
 {
 }
 
+bool OfflineAudioContext::suspendIfNecessary()
+{
+    ASSERT(!isMainThread());
+
+    if (m_isSuspendScheduled && m_suspendTime <= currentTime()) {
+        m_isSuspendScheduled = false;
+        m_suspendTime = -0.0;
+        return true;
+    }
+
+    return false;
+}
+
 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 suspendTime)
+{
+    ASSERT(isMainThread());
+    AutoLocker locker(this);
+
+    // suspendTime should be greater than currentTime. Otherwise stop the
+    // rendering as soon as possible.
+    //
+    // TODO: add extra time when suspendTime is earlier than currentTime
+    if (currentTime() < suspendTime) {
+        m_isSuspendScheduled = true;
+        m_suspendTime = suspendTime;
+    }
+
+    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+    m_offlineSuspendResolvers.append(resolver);
+
+    // fprintf(stderr, "suspend scheduled = %f\n", m_suspendTime);
+
+    return promise;
+}
+
+ScriptPromise OfflineAudioContext::resumeOfflineRendering(ScriptState* scriptState)
+{
+    ASSERT(isMainThread());
+    AutoLocker locker(this);
+
+    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+    m_offlineResumeResolvers.append(resolver);
+
+    // Calling startRendering() in OfflineAudioDestinationHandler.
+    destination()->audioDestinationHandler().startRendering();
+    setContextState(Running);
+
+    return promise;
+}
+
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)