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:
+    class SuspendResumeResolver {

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

Should we consider take this definition out of the AudioContext? It seems like
AudioContext keeps getting longer and longer. Just a thought. Also I believe we
need some explanation - regarding why it is needed and what it does.

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

It seems natural to keep it here since it's only relevant to an AudioContext.

I will add some documentation, however.

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

Acknowledged.

+    public:
+        enum ResolverType {
+            ResolverTypeSuspend,
+            ResolverTypeResume
+        };
+
+        static SuspendResumeResolver* createSuspendHandler(PassRefPtrWillBeRawPtr<ScriptPromiseResolver>);
+        static SuspendResumeResolver* createResumeHandler(PassRefPtrWillBeRawPtr<ScriptPromiseResolver>);
+        ResolverType handlerType() { return m_resolverType; }
+        PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver() { return m_resolver; }
+
+    private:
+        SuspendResumeResolver(ResolverType, PassRefPtrWillBeRawPtr<ScriptPromiseResolver>);
+        ~SuspendResumeResolver();
+        ResolverType m_resolverType;
+        RefPtrWillBeRawPtr<ScriptPromiseResolver> 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;
 
-    // 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