Merge 92658 - Fix thread-safety of AudioNode deletion

Source/WebCore/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 19 matching lines @@
 #include "AudioBus.h"
 #include "AudioDestinationNode.h"
 #include "EventListener.h"
 #include "EventTarget.h"
 #include "HRTFDatabaseLoader.h"
 #include <wtf/HashSet.h>
 #include <wtf/OwnPtr.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
 #include <wtf/RefPtr.h>
+#include <wtf/ThreadSafeRefCounted.h>
 #include <wtf/Threading.h>
 #include <wtf/Vector.h>
 #include <wtf/text/AtomicStringHash.h>
 
 namespace WebCore {
 
 class ArrayBuffer;
 class AudioBuffer;
 class AudioBufferCallback;
 class AudioBufferSourceNode;
 class AudioChannelMerger;
 class AudioChannelSplitter;
 class AudioGainNode;
 class AudioPannerNode;
 class AudioListener;
 class BiquadFilterNode;
 class DelayNode;
 class Document;
 class LowPass2FilterNode;
 class HighPass2FilterNode;
 class ConvolverNode;
 class DynamicsCompressorNode;
 class RealtimeAnalyserNode;
 class WaveShaperNode;
 class JavaScriptAudioNode;
 
 // AudioContext is the cornerstone of the web audio API and all AudioNodes are created from it.
 // For thread safety between the audio thread and the main thread, it has a rendering graph locking mechanism. 
 
-class AudioContext : public ActiveDOMObject, public RefCounted<AudioContext>, public EventTarget {
+class AudioContext : public ActiveDOMObject, public ThreadSafeRefCounted<AudioContext>, public EventTarget {
 public:
     // Create an AudioContext for rendering to the audio hardware.
     static PassRefPtr<AudioContext> create(Document*);
 
     // Create an AudioContext for offline (non-realtime) rendering.
     static PassRefPtr<AudioContext> createOfflineContext(Document*, unsigned numberOfChannels, size_t numberOfFrames, double sampleRate, ExceptionCode&);
 
     virtual ~AudioContext();
 
     bool isInitialized() const;
@@ skipping 48 matching lines @@
 
     // Called at the start of each render quantum.
     void handlePreRenderTasks();
 
     // Called at the end of each render quantum.
     void handlePostRenderTasks();
 
     // Called periodically at the end of each render quantum to dereference finished source nodes.
     void derefFinishedSourceNodes();
 
-    // We reap all marked nodes at the end of each realtime render quantum in deleteMarkedNodes().
+    // We schedule deletion of all marked nodes at the end of each realtime render quantum.
     void markForDeletion(AudioNode*);
     void deleteMarkedNodes();
-
+    
     // Keeps track of the number of connections made.
     void incrementConnectionCount()
     {
         ASSERT(isMainThread());
         m_connectionCount++;
     }
 
     unsigned connectionCount() const { return m_connectionCount; }
 
     //
@@ skipping 49 matching lines @@
     void markAudioNodeOutputDirty(AudioNodeOutput*);
 
     // EventTarget
     virtual ScriptExecutionContext* scriptExecutionContext() const;
     virtual AudioContext* toAudioContext();
     virtual EventTargetData* eventTargetData() { return &m_eventTargetData; }
     virtual EventTargetData* ensureEventTargetData() { return &m_eventTargetData; }
 
     DEFINE_ATTRIBUTE_EVENT_LISTENER(complete);
 
-    // Reconcile ref/deref which are defined both in AudioNode and EventTarget.
-    using RefCounted<AudioContext>::ref;
-    using RefCounted<AudioContext>::deref;
+    // Reconcile ref/deref which are defined both in ThreadSafeRefCounted and EventTarget.
+    using ThreadSafeRefCounted<AudioContext>::ref;
+    using ThreadSafeRefCounted<AudioContext>::deref;
 
     void startRendering();
     void fireCompletionEvent();
     
     static unsigned s_hardwareContextCount;
     
 private:
     AudioContext(Document*);
     AudioContext(Document*, unsigned numberOfChannels, size_t numberOfFrames, double sampleRate);
     void constructCommon();
 
     void lazyInitialize();
     void uninitialize();
+
+    void scheduleNodeDeletion();
+    static void deleteMarkedNodesDispatch(void* userData);
     
     bool m_isInitialized;
     bool m_isAudioThreadFinished;
     bool m_isAudioThreadShutdown;
 
     Document* m_document;
 
     // The context itself keeps a reference to all source nodes.  The source nodes, then reference all nodes they're connected to.
     // In turn, these nodes reference all nodes they're connected to.  All nodes are ultimately connected to the AudioDestinationNode.
     // When the context dereferences a source node, it will be deactivated from the rendering graph along with all other nodes it is
@@ skipping 12 matching lines @@
     Vector<RefPtr<AudioBuffer> > m_allocatedBuffers;
 
     // Only accessed in the audio thread.
     Vector<AudioNode*> m_finishedNodes;
 
     // We don't use RefPtr<AudioNode> here because AudioNode has a more complex ref() / deref() implementation
     // with an optional argument for refType.  We need to use the special refType: RefTypeConnection
     // Either accessed when the graph lock is held, or on the main thread when the audio thread has finished.
     Vector<AudioNode*> m_referencedNodes;
 
-    // Accumulate nodes which need to be deleted at the end of a render cycle (in realtime thread) here.
+    // Accumulate nodes which need to be deleted here.
+    // They will be scheduled for deletion (on the main thread) at the end of a render cycle (in realtime thread).
     Vector<AudioNode*> m_nodesToDelete;
+    bool m_isDeletionScheduled;
 
     // Only accessed when the graph lock is held.
     HashSet<AudioNodeInput*> m_dirtyAudioNodeInputs;
     HashSet<AudioNodeOutput*> m_dirtyAudioNodeOutputs;
     void handleDirtyAudioNodeInputs();
     void handleDirtyAudioNodeOutputs();
 
     OwnPtr<AudioBus> m_temporaryMonoBus;
     OwnPtr<AudioBus> m_temporaryStereoBus;
 
@@ skipping 29 matching lines @@
     RefPtr<AudioBuffer> m_renderTarget;
     
     bool m_isOfflineContext;
 
     AsyncAudioDecoder m_audioDecoder;
 };
 
 } // WebCore
 
 #endif // AudioContext_h