Implement suspend() and resume() for OfflineAudioContext

third_party/WebKit/Source/modules/webaudio/DeferredTaskHandler.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 20 matching lines @@
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/ThreadSafeRefCounted.h"
 #include "wtf/Threading.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 class AbstractAudioContext;
+class OfflineAudioContext;
 class AudioHandler;
 class AudioNodeOutput;
 class AudioSummingJunction;
 
 // DeferredTaskHandler manages the major part of pre- and post- rendering tasks,
 // and provides a lock mechanism against the audio rendering graph. A
 // DeferredTaskHandler object is created when an AbstractAudioContext object is created.
 //
 // DeferredTaskHandler outlives the AbstractAudioContext only if all of the following
 // conditions match:
@@ skipping 52 matching lines @@
     // TODO(hongchan): Use no-barrier load here. (crbug.com/247328)
     //
     // It is okay to use a relaxed (no-barrier) load here. Because the data
     // referenced by m_audioThread is not actually being used, thus we do not
     // need a barrier between the load of m_audioThread and of that data.
     bool isAudioThread() const { return currentThread() == acquireLoad(&m_audioThread); }
 
     void lock();
     bool tryLock();
     void unlock();
+
+    // This locks the audio render thread for OfflineAudioContext rendering.
+    // MUST NOT be used in the real-time audio context.
+    void offlineLock();
+
 #if ENABLE(ASSERT)
     // Returns true if this thread owns the context's lock.
     bool isGraphOwner();
 #endif
 
     class MODULES_EXPORT AutoLocker {
         STACK_ALLOCATED();
     public:
         explicit AutoLocker(DeferredTaskHandler& handler)
             : m_handler(handler)
         {
             m_handler.lock();
         }
         explicit AutoLocker(AbstractAudioContext*);
 
         ~AutoLocker() { m_handler.unlock(); }
 
     private:
         DeferredTaskHandler& m_handler;
     };
 
+    // This is for locking offline render thread (which is considered as the
+    // audio thread) with unlocking on self-destruction at the end of the scope.
+    // Also note that it uses lock() rather than tryLock() because the timing
+    // MUST be accurate on offline rendering.
+    class MODULES_EXPORT OfflineGraphAutoLocker {
+        STACK_ALLOCATED();
+    public:
+        explicit OfflineGraphAutoLocker(OfflineAudioContext*);
+
+        ~OfflineGraphAutoLocker() { m_handler.unlock(); }
+
+    private:
+        DeferredTaskHandler& m_handler;
+    };
+
 private:
     DeferredTaskHandler();
     void updateAutomaticPullNodes();
     void updateChangedChannelCountMode();
     void handleDirtyAudioSummingJunctions();
     void handleDirtyAudioNodeOutputs();
     void deleteHandlersOnMainThread();
 
     // For the sake of thread safety, we maintain a seperate Vector of automatic
     // pull nodes for rendering in m_renderingAutomaticPullNodes.  It will be
@@ skipping 21 matching lines @@
     Vector<RefPtr<AudioHandler>> m_deletableOrphanHandlers;
 
     // Graph locking.
     RecursiveMutex m_contextGraphMutex;
     volatile ThreadIdentifier m_audioThread;
 };
 
 } // namespace blink
 
 #endif // DeferredTaskHandler_h