Implement tail processing for AudioNodes

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 87 matching lines @@
 
   // In AudioNode::breakConnection() and deref(), a tryLock() is used for
   // calling actual processing, but if it fails keep track here.
   void AddDeferredBreakConnection(AudioHandler&);
   void BreakConnections();
 
   void AddRenderingOrphanHandler(PassRefPtr<AudioHandler>);
   void RequestToDeleteHandlersOnMainThread();
   void ClearHandlersToBeDeleted();
 
+  // If |node| requires tail processing, add it to the list of tail
+  // nodes so the tail is processed.
+  void AddTailProcessingNode(PassRefPtr<AudioHandler> node);
+
+  // Remove |node| from the list of tail nodes (because the tail
+  // processing is complete).
+  void RemoveTailProcessingNode(PassRefPtr<AudioHandler> node);
+
   //
   // Thread Safety and Graph Locking:
   //
   void SetAudioThreadToCurrentThread();
   ThreadIdentifier AudioThread() const { return AcquireLoad(&audio_thread_); }
 
   // 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
@@ skipping 46 matching lines @@
 
  private:
   DeferredTaskHandler();
   void UpdateAutomaticPullNodes();
   void UpdateChangedChannelCountMode();
   void UpdateChangedChannelInterpretation();
   void HandleDirtyAudioSummingJunctions();
   void HandleDirtyAudioNodeOutputs();
   void DeleteHandlersOnMainThread();
 
+  // Check tail processing nodes and remove any node if the tail has
+  // been processed.
+  void UpdateTailProcessingNodes();
+
   // For the sake of thread safety, we maintain a seperate Vector of automatic
   // pull nodes for rendering in m_renderingAutomaticPullNodes.  It will be
   // copied from m_automaticPullNodes by updateAutomaticPullNodes() at the
   // very start or end of the rendering quantum.
   HashSet<AudioHandler*> automatic_pull_nodes_;
   Vector<AudioHandler*> rendering_automatic_pull_nodes_;
   // m_automaticPullNodesNeedUpdating keeps track if m_automaticPullNodes is
   // modified.
   bool automatic_pull_nodes_need_updating_;
 
   // Collection of nodes where the channel count mode has changed. We want the
   // channel count mode to change in the pre- or post-rendering phase so as
   // not to disturb the running audio thread.
   HashSet<AudioHandler*> deferred_count_mode_change_;
 
   HashSet<AudioHandler*> deferred_channel_interpretation_change_;
 
   // These two HashSet must be accessed only when the graph lock is held.
   // These raw pointers are safe because their destructors unregister them.
   HashSet<AudioSummingJunction*> dirty_summing_junctions_;
   HashSet<AudioNodeOutput*> dirty_audio_node_outputs_;
 
   // Only accessed in the audio thread.
   Vector<AudioHandler*> deferred_break_connection_list_;
 
   Vector<RefPtr<AudioHandler>> rendering_orphan_handlers_;
   Vector<RefPtr<AudioHandler>> deletable_orphan_handlers_;
 
+  // Nodes that are processing its tail.
+  Vector<RefPtr<AudioHandler>> tail_processing_nodes_;
+
   // Graph locking.
   RecursiveMutex context_graph_mutex_;
   volatile ThreadIdentifier audio_thread_;
 };
 
 }  // namespace blink
 
 #endif  // DeferredTaskHandler_h