Process suspend() and resume() in call order

Source/modules/webaudio/AudioContext.cpp

 /*
  * Copyright (C) 2010, 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 60 matching lines @@
 #include <stdio.h>
 #endif
 
 namespace blink {
 
 // Don't allow more than this number of simultaneous AudioContexts talking to hardware.
 const unsigned MaxHardwareContexts = 6;
 unsigned AudioContext::s_hardwareContextCount = 0;
 unsigned AudioContext::s_contextId = 0;
 
+AudioContext::SuspendResumeHandler::SuspendResumeHandler(

[hongchan, 2015/05/04 17:28:38]

Can we change the name of this class to the wrapper or container? We're already
using the name "handler" in a big way.

[Raymond Toy, 2015/05/04 17:38:34]

Are you looking at the right version? I renamed it to SuspendResumeResolver in
patch 2.

[hongchan, 2015/05/04 17:41:50]

Oh, yes. Resolver is good.

+    ResolverType resolverType,
+    PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+    : m_resolverType(resolverType)
+    , m_resolver(resolver)
+{
+}
+
+AudioContext::SuspendResumeHandler* AudioContext::SuspendResumeHandler::createSuspendHandler(
+    PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+{
+    return new SuspendResumeHandler(ResolverTypeSuspend, resolver);
+}
+
+AudioContext::SuspendResumeHandler* AudioContext::SuspendResumeHandler::createResumeHandler(
+    PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+{
+    return new SuspendResumeHandler(ResolverTypeResume, resolver);
+}
+
 AudioContext* AudioContext::create(Document& document, ExceptionState& exceptionState)
 {
     ASSERT(isMainThread());
     if (s_hardwareContextCount >= MaxHardwareContexts) {
         exceptionState.throwDOMException(
             NotSupportedError,
             ExceptionMessages::indexExceedsMaximumBound(
                 "number of hardware contexts",
                 s_hardwareContextCount,
                 MaxHardwareContexts));
         return nullptr;
     }
 
     AudioContext* audioContext = new AudioContext(&document);
     audioContext->suspendIfNeeded();
     return audioContext;
 }
 
 // Constructor for rendering to the audio hardware.
 AudioContext::AudioContext(Document* document)
     : ActiveDOMObject(document)
     , m_isStopScheduled(false)
     , m_isCleared(false)
     , m_isInitialized(false)
     , m_destinationNode(nullptr)
-    , m_isResolvingResumePromises(false)
+    , m_isResolvingSuspendResumePromises(false)
     , m_connectionCount(0)
     , m_didInitializeContextGraphMutex(false)
     , m_deferredTaskHandler(DeferredTaskHandler::create())
     , m_isOfflineContext(false)
     , m_contextState(Suspended)
     , m_cachedSampleFrame(0)
 {
     m_didInitializeContextGraphMutex = true;
     m_destinationNode = DefaultAudioDestinationNode::create(this);
 
     initialize();
 }
 
 // Constructor for offline (non-realtime) rendering.
 AudioContext::AudioContext(Document* document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate)
     : ActiveDOMObject(document)
     , m_isStopScheduled(false)
     , m_isCleared(false)
     , m_isInitialized(false)
     , m_destinationNode(nullptr)
-    , m_isResolvingResumePromises(false)
+    , m_isResolvingSuspendResumePromises(false)
     , m_connectionCount(0)
     , m_didInitializeContextGraphMutex(false)
     , m_deferredTaskHandler(DeferredTaskHandler::create())
     , m_isOfflineContext(true)
     , m_contextState(Suspended)
     , m_cachedSampleFrame(0)
 {
     m_didInitializeContextGraphMutex = true;
     // Create a new destination for offline rendering.
     m_renderTarget = AudioBuffer::create(numberOfChannels, numberOfFrames, sampleRate);
     if (m_renderTarget.get())
         m_destinationNode = OfflineAudioDestinationNode::create(this, m_renderTarget.get());
 
     initialize();
 }
 
 AudioContext::~AudioContext()
 {
 #if DEBUG_AUDIONODE_REFERENCES
     fprintf(stderr, "%p: AudioContext::~AudioContext(): %u\n", this, m_contextId);
 #endif
     deferredTaskHandler().contextWillBeDestroyed();
     // AudioNodes keep a reference to their context, so there should be no way to be in the destructor if there are still AudioNodes around.
     ASSERT(!m_isInitialized);
     ASSERT(!m_activeSourceNodes.size());
     ASSERT(!m_finishedSourceHandlers.size());
-    ASSERT(!m_suspendResolvers.size());
-    ASSERT(!m_isResolvingResumePromises);
-    ASSERT(!m_resumeResolvers.size());
+    ASSERT(!m_suspendResumeHandlers.size());
+    ASSERT(!m_isResolvingSuspendResumePromises);
 }
 
 void AudioContext::initialize()
 {
     if (isInitialized())
         return;
 
     FFTFrame::initialize();
     m_listener = AudioListener::create();
 
@@ skipping 586 matching lines @@
             DOMException::create(
                 InvalidAccessError,
                 "cannot suspend an OfflineAudioContext"));
     }
 
     RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     // Save the resolver.  If the context is running, it will get resolved at the end of a rendering
     // quantum.  Otherwise, resolve it now.
-    m_suspendResolvers.append(resolver);
+    m_suspendResumeHandlers.append(SuspendResumeHandler::createSuspendHandler(resolver));
 
     if (m_contextState != Running) {
         // Context is not running so we can't wait for a rendering quantum to resolve the
-        // promise. Just resolve it now (along with any other pending suspend promises).
-        resolvePromisesForSuspendOnMainThread();
+        // promise. Just resolve it now (along with any other pending promises).
+        resolvePromisesForSuspendResumeOnMainThread();
     }
 
     return promise;
 }
 
 ScriptPromise AudioContext::resumeContext(ScriptState* scriptState)
 {
     ASSERT(isMainThread());
     AutoLocker locker(this);
 
@@ skipping 15 matching lines @@
 
     RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     // Restart the destination node to pull on the audio graph.
     if (m_destinationNode)
         startRendering();
 
     // Save the resolver which will get resolved when the destination node starts pulling on the
     // graph again.
-    m_resumeResolvers.append(resolver);
+    m_suspendResumeHandlers.append(SuspendResumeHandler::createResumeHandler(resolver));

[hongchan, 2015/05/04 17:28:38]

At a first glance, I read this code like "create/resume the audio context
handler."

[Raymond Toy, 2015/05/04 17:44:07]

What are you suggesting?  This name is bad and I should rename it to something
else?

[hongchan, 2015/05/04 17:50:52]

My suggestion was for the previous patch set, which is wrong. Please have a look
at the new comment.

 
     return promise;
 }
 
 void AudioContext::notifySourceNodeFinishedProcessing(AudioHandler* handler)
 {
     ASSERT(isAudioThread());
     m_finishedSourceHandlers.append(handler);
 }
 
@@ skipping 47 matching lines @@
 
 void AudioContext::handlePreRenderTasks()
 {
     ASSERT(isAudioThread());
 
     // At the beginning of every render quantum, try to update the internal rendering graph state (from main thread changes).
     // It's OK if the tryLock() fails, we'll just take slightly longer to pick up the changes.
     if (tryLock()) {
         deferredTaskHandler().handleDeferredTasks();
 
-        resolvePromisesForResume();
 
         // Check to see if source nodes can be stopped because the end time has passed.
         handleStoppableSourceNodes();
 
         // Update the cached sample frame value.
         m_cachedSampleFrame = currentSampleFrame();
 
         unlock();
     }
 }
 
 void AudioContext::handlePostRenderTasks()
 {
     ASSERT(isAudioThread());
 
     // Must use a tryLock() here too.  Don't worry, the lock will very rarely be contended and this method is called frequently.
     // The worst that can happen is that there will be some nodes which will take slightly longer than usual to be deleted or removed
     // from the render graph (in which case they'll render silence).
     if (tryLock()) {
         // Take care of AudioNode tasks where the tryLock() failed previously.
         deferredTaskHandler().breakConnections();
 
         // Dynamically clean up nodes which are no longer needed.
         releaseFinishedSourceNodes();
 
         deferredTaskHandler().handleDeferredTasks();
         deferredTaskHandler().requestToDeleteHandlersOnMainThread();
 
-        resolvePromisesForSuspend();
+        resolvePromisesForSuspendResume();
 
         unlock();
     }
 }
 
-void AudioContext::resolvePromisesForResumeOnMainThread()
+void AudioContext::resolvePromisesForSuspendResumeOnMainThread()
 {
     ASSERT(isMainThread());
     AutoLocker locker(this);
 
-    for (auto& resolver : m_resumeResolvers) {
+    for (auto& handler : m_suspendResumeHandlers) {
+        bool isSuspend = handler->handlerType() == SuspendResumeHandler::ResolverTypeSuspend;
+
+        // Stop or start rendering depending on the type of handler.
+        if (m_destinationNode) {
+            if (isSuspend) {
+                stopRendering();
+            } else {
+                // Normally we don't need this, but if suspend() and resume() calls have piled up,
+                // the context may have been suspended again, and we want to start rendering for
+                // sure.  See crbug.com/483269.
+                startRendering();
+            }
+        }
+
         if (m_contextState == Closed) {
-            resolver->reject(
-                DOMException::create(InvalidStateError, "Cannot resume a context that has been closed"));
+            String message = isSuspend ? "suspend" : "resume";
+            handler->resolver()->reject(DOMException::create(InvalidStateError,
+                "cannot " + message + " a context that has been closed"));
         } else {
-            resolver->resolve();
+            handler->resolver()->resolve();
         }
     }
 
-    m_resumeResolvers.clear();
-    m_isResolvingResumePromises = false;
+    m_suspendResumeHandlers.clear();
+    m_isResolvingSuspendResumePromises = false;
 }
 
-void AudioContext::resolvePromisesForResume()
-{
-    // This runs inside the AudioContext's lock when handling pre-render tasks.
-    ASSERT(isAudioThread());
-    ASSERT(isGraphOwner());
-
-    // Resolve any pending promises created by resume(). Only do this if we haven't already started
-    // resolving these promises. This gets called very often and it takes some time to resolve the
-    // promises in the main thread.
-    if (!m_isResolvingResumePromises && m_resumeResolvers.size() > 0) {
-        m_isResolvingResumePromises = true;
-        Platform::current()->mainThread()->postTask(FROM_HERE, threadSafeBind(&AudioContext::resolvePromisesForResumeOnMainThread, this));
-    }
-}
-
-void AudioContext::resolvePromisesForSuspendOnMainThread()
-{
-    ASSERT(isMainThread());
-    AutoLocker locker(this);
-
-    // We can stop rendering now.
-    if (m_destinationNode)
-        stopRendering();
-
-    for (auto& resolver : m_suspendResolvers) {
-        if (m_contextState == Closed) {
-            resolver->reject(
-                DOMException::create(InvalidStateError, "Cannot suspend a context that has been closed"));
-        } else {
-            resolver->resolve();
-        }
-    }
-
-    m_suspendResolvers.clear();
-}
-
-void AudioContext::resolvePromisesForSuspend()
+void AudioContext::resolvePromisesForSuspendResume()
 {
     // This runs inside the AudioContext's lock when handling pre-render tasks.
     ASSERT(isAudioThread());
     ASSERT(isGraphOwner());
 
     // Resolve any pending promises created by suspend()
-    if (m_suspendResolvers.size() > 0)
-        Platform::current()->mainThread()->postTask(FROM_HERE, threadSafeBind(&AudioContext::resolvePromisesForSuspendOnMainThread, this));
+    if (!m_isResolvingSuspendResumePromises && m_suspendResumeHandlers.size() > 0) {
+        m_isResolvingSuspendResumePromises = true;
+        Platform::current()->mainThread()->postTask(FROM_HERE,
+            threadSafeBind(&AudioContext::resolvePromisesForSuspendResumeOnMainThread, this));
+    }
 }
 
 void AudioContext::rejectPendingResolvers()
 {
     ASSERT(isMainThread());
 
     // Audio context is closing down so reject any suspend or resume promises that are still
     // pending.
 
-    for (auto& resolver : m_suspendResolvers) {
-        resolver->reject(DOMException::create(InvalidStateError, "Audio context is going away"));
-    }
-    m_suspendResolvers.clear();
-
-    for (auto& resolver : m_resumeResolvers) {
-        resolver->reject(DOMException::create(InvalidStateError, "Audio context is going away"));
-    }
-    m_resumeResolvers.clear();
-    m_isResolvingResumePromises = false;
+    for (auto& handler : m_suspendResumeHandlers)
+        handler->resolver()->reject(DOMException::create(InvalidStateError, "Audio context is going away"));
+    m_suspendResumeHandlers.clear();
 }
 
 const AtomicString& AudioContext::interfaceName() const
 {
     return EventTargetNames::AudioContext;
 }
 
 ExecutionContext* AudioContext::executionContext() const
 {
     return m_isStopScheduled ? 0 : ActiveDOMObject::executionContext();
@@ skipping 56 matching lines @@
     visitor->trace(m_destinationNode);
     visitor->trace(m_listener);
     // trace() can be called in AudioContext constructor, and
     // m_contextGraphMutex might be unavailable.
     if (m_didInitializeContextGraphMutex) {
         AutoLocker lock(this);
         visitor->trace(m_activeSourceNodes);
     } else {
         visitor->trace(m_activeSourceNodes);
     }
-    visitor->trace(m_resumeResolvers);
-    visitor->trace(m_suspendResolvers);
     RefCountedGarbageCollectedEventTargetWithInlineData<AudioContext>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 SecurityOrigin* AudioContext::securityOrigin() const
 {
     if (executionContext())
         return executionContext()->securityOrigin();
 
     return nullptr;
@@ skipping 24 matching lines @@
     // the destination node can GCed if JS has no references. stop() will also resolve the Promise
     // created here.
     stop();
 
     return promise;
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)