Implement suspend() and resume() for OfflineAudioContext

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 202 matching lines @@
     static unsigned maxNumberOfChannels() { return MaxNumberOfChannels;}
 
     // EventTarget
     virtual const AtomicString& interfaceName() const override final;
     virtual ExecutionContext* executionContext() const override final;
 
     DEFINE_ATTRIBUTE_EVENT_LISTENER(complete);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(statechange);
 
     void startRendering();
+    void notifyStateChange();
+
+    // From offline rendering.
+    void fireSuspendEvent();
     void fireCompletionEvent();
-    void notifyStateChange();
+    virtual bool suspendIfNecessary();
 
     // A context is considered closed if:
     //  - closeContext() has been called, even if the audio HW has not yet been
     //    stopped.  It will be stopped eventually.
     //  - it has been stopped (or is stopping) by its execution context.
     bool isContextClosed() const { return m_closeResolver || m_isStopScheduled || m_isCleared; }
 
     static unsigned s_hardwareContextCount;
     static unsigned s_contextId;
 
     // 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;
+    Member<AudioDestinationNode> m_destinationNode;
+    bool m_didInitializeContextGraphMutex;
+    Member<AudioBuffer> m_renderTarget;
+
+    // The state of the AudioContext.
+    void setContextState(AudioContextState);
+    AudioContextState m_contextState;
+
 private:
     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&);
 
     // Set to true when the destination node has been initialized and is ready to process data.
     bool m_isInitialized;
 
     // When the context goes away, there might still be some sources which
     // haven't finished playing.  Make sure to release them here.
     void releaseActiveSourceNodes();
 
-    Member<AudioDestinationNode> m_destinationNode;

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

Try not to move things around.  It makes it hard to figure out what changed and
this particular one looks like m_destinationNode was removed, but it was just
moved above.

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

Yes, this relocation was not necessary. However, there are things need to be
moved because of the order of initializers. Some methods and variables should be
accessed by OAC so they need to be in the protected state (from the private).

This is just work-in-progress artifacts. Will be cleaned up.

+
     Member<AudioListener> m_listener;
 
     // Only accessed in the audio thread.
     // These raw pointers are safe because AudioSourceNodes in
     // m_activeSourceNodes own them.
     Vector<AudioHandler*> m_finishedSourceHandlers;
 
     // List of source nodes. This is either accessed when the graph lock is
     // held, or on the main thread when the audio thread has finished.
     // Oilpan: This Vector holds connection references. We must call
@@ skipping 19 matching lines @@
     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;
 
     unsigned m_connectionCount;
 
-    // Graph locking.
-    bool m_didInitializeContextGraphMutex;
     RefPtr<DeferredTaskHandler> m_deferredTaskHandler;
 
-    Member<AudioBuffer> m_renderTarget;
-
     bool m_isOfflineContext;
 
-    // The state of the AudioContext.
-    AudioContextState m_contextState;
-    void setContextState(AudioContextState);
-
     AsyncAudioDecoder m_audioDecoder;
 
     // The Promise that is returned by close();
     RefPtrWillBeMember<ScriptPromiseResolver> m_closeResolver;
 
     // Follows the destination's currentSampleFrame, but might be slightly behind due to locking.
     size_t m_cachedSampleFrame;
 
     // Tries to handle AudioBufferSourceNodes that were started but became disconnected or was never
     // connected. Because these never get pulled anymore, they will stay around forever. So if we
     // can, try to stop them so they can be collected.
     void handleStoppableSourceNodes();
 
     // 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