Process suspend() and resume() in call order

Source/modules/webaudio/AudioContext.h

Index: Source/modules/webaudio/AudioContext.h
diff --git a/Source/modules/webaudio/AudioContext.h b/Source/modules/webaudio/AudioContext.h
index 5b19a40d2b8248048d972429ba0e5fe3275e7b52..ca32230f5c07316cb4ed29f96d72d773dfeaac87 100644
--- a/Source/modules/webaudio/AudioContext.h
+++ b/Source/modules/webaudio/AudioContext.h
@@ -241,6 +241,27 @@ protected:
 
     RefPtrWillBeMember<ScriptPromiseResolver> m_offlineResolver;
 private:
+    // Helper class to wrap a ScriptPromiseResolver to include information on whether the resolver
+    // was created by suspend() or resume() so that we can process them correctly.
+    class SuspendResumeResolver {

[haraken, 2015/05/04 23:24:41]

This needs to be:

  class SuspendResumeResolver : public GarbageCollected<SuspendResumeResolver> {
};

Otherwise m_resolver won't be traced and thus wrongly collected.

[Raymond Toy, 2015/05/14 21:26:05]

When I do this and make m_resolver be a
RefPtrWillBeMember<ScriptPromiseResolver>, I get compiler errors:

../../third_party/WebKit/Source/modules/webaudio/AudioContext.h:246:5: error:
[blink-gc] Class 'SuspendResumeResolver' requires finalization.
    class SuspendResumeResolver : public GarbageCollected<SuspendResumeResolver>
{
    ^
../../third_party/WebKit/Source/modules/webaudio/AudioContext.h:262:9: note:
[blink-gc] Field 'm_resolver' requiring finalization declared here:
        RefPtrWillBeMember<ScriptPromiseResolver> m_resolver;
        ^

What else do I need to do?

[haraken, 2015/05/14 21:28:27]

You'll need to use NoBaseWillBeGarbageCollected.

In non-oilpan builds, SuspendResumeResolver should not be a GarbageCollected
class.

+    public:
+        enum ResolverType {
+            ResolverTypeSuspend,
+            ResolverTypeResume
+        };
+
+        static SuspendResumeResolver* createSuspendResolver(PassRefPtrWillBeRawPtr<ScriptPromiseResolver>);
+        static SuspendResumeResolver* createResumeResolver(PassRefPtrWillBeRawPtr<ScriptPromiseResolver>);
+        ResolverType handlerType() const { return m_resolverType; }
+        PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver() { return m_resolver; }
+
+    private:
+        SuspendResumeResolver(ResolverType, PassRefPtrWillBeRawPtr<ScriptPromiseResolver>);
+        ~SuspendResumeResolver();
+        ResolverType m_resolverType;
+        RefPtrWillBeRawPtr<ScriptPromiseResolver> m_resolver;

[haraken, 2015/05/04 23:24:41]

RefPtrWillBeMember<ScriptPromiseResolver>

Also you need to trace the m_resolver.

+    };
+
     void initialize();
     void uninitialize();
 
@@ -279,23 +300,20 @@ private:
     void stopRendering();
 
     // Handle Promises for resume() and suspend()
-    void resolvePromisesForResume();
-    void resolvePromisesForResumeOnMainThread();
+    void resolvePromisesForSuspendResume();
+    void resolvePromisesForSuspendResumeOnMainThread();
 
-    void resolvePromisesForSuspend();
-    void resolvePromisesForSuspendOnMainThread();
+    // Vector of promises created by suspend() and resume().  It takes time to handle them, so we
+    // collect all of the promises here until they can be resolved or rejected.  We can then also
+    // process them in the order in which suspend/resume was called.
+    Vector<SuspendResumeResolver*> m_suspendResumeResolvers;

[haraken, 2015/05/04 23:24:40]

WillBeHeapVector<OwnPtrWillBeMember<SuspendResumeResolver>>

In non-oilpan, it is wrong to hold SuspendResumeResolver by a raw pointer. It
needs to be an OwnPtr. Otherwise SuspendResumeResolver will leak.

In oilpan, you need to hold SuspendResumeResolver by a Member.

 
-    // Vector of promises created by resume(). It takes time to handle them, so we collect all of
-    // the promises here until they can be resolved or rejected.
-    WillBeHeapVector<RefPtrWillBeMember<ScriptPromiseResolver>> m_resumeResolvers;
-    // Like m_resumeResolvers but for suspend().
-    WillBeHeapVector<RefPtrWillBeMember<ScriptPromiseResolver>> m_suspendResolvers;
     void rejectPendingResolvers();
 
-    // True if we're in the process of resolving promises for resume().  Resolving can take some
-    // time and the audio context process loop is very fast, so we don't want to call resolve an
-    // excessive number of times.
-    bool m_isResolvingResumePromises;
+    // True if we're in the process of resolving promises for suspend()/resume().  Resolving can
+    // take some time and the audio context process loop is very fast, so we don't want to call
+    // resolve an excessive number of times.
+    bool m_isResolvingSuspendResumePromises;
 
     unsigned m_connectionCount;