Process suspend() and resume() in call order

Source/modules/webaudio/AudioContext.h

 /*
  * 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 223 matching lines @@
 
     // Get the security origin for this audio context.
     SecurityOrigin* securityOrigin() const;
 
 protected:
     explicit AudioContext(Document*);
     AudioContext(Document*, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate);
 
     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();
 
     // ExecutionContext calls stop twice.
     // We'd like to schedule only one stop action for them.
     bool m_isStopScheduled;
     bool m_isCleared;
     void clear();
 
     void throwExceptionForClosedState(ExceptionState&);
@@ skipping 18 matching lines @@
     // Oilpan: This Vector holds connection references. We must call
     // AudioHandler::makeConnection when we add an AudioNode to this, and must
     // call AudioHandler::breakConnection() when we remove an AudioNode from
     // this.
     HeapVector<Member<AudioNode>> m_activeSourceNodes;
 
     // Stop rendering the audio graph.
     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;
 
     // Graph locking.
     bool m_didInitializeContextGraphMutex;
     RefPtr<DeferredTaskHandler> m_deferredTaskHandler;
 
     Member<AudioBuffer> m_renderTarget;
 
     bool m_isOfflineContext;
@@ skipping 18 matching lines @@
     // This is considering 32 is large enough for multiple channels audio.
     // It is somewhat arbitrary and could be increased if necessary.
     enum { MaxNumberOfChannels = 32 };
 
     unsigned m_contextId;
 };
 
 } // namespace blink
 
 #endif // AudioContext_h