Defer changes to channelInterpretation to pre/post rendering.

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 61 matching lines @@
     void removeAutomaticPullNode(AudioHandler*);
     // Called right before handlePostRenderTasks() to handle nodes which need to
     // be pulled even when they are not connected to anything.
     void processAutomaticPullNodes(size_t framesToProcess);
 
     // Keep track of AudioNode's that have their channel count mode changed. We
     // process the changes in the post rendering phase.
     void addChangedChannelCountMode(AudioHandler*);
     void removeChangedChannelCountMode(AudioHandler*);
 
+    // Keep track of AudioNode's that have their channel interpretation
+    // changed. We process the changes in the post rendering phase.
+    void addChangedChannelInterpretation(AudioHandler*);
+    void removeChangedChannelInterpretation(AudioHandler*);
+
     // Only accessed when the graph lock is held.
     void markSummingJunctionDirty(AudioSummingJunction*);
     // Only accessed when the graph lock is held. Must be called on the main thread.
     void removeMarkedSummingJunction(AudioSummingJunction*);
 
     void markAudioNodeOutputDirty(AudioNodeOutput*);
     void removeMarkedAudioNodeOutput(AudioNodeOutput*);
 
     // In AudioNode::breakConnection() and deref(), a tryLock() is used for
     // calling actual processing, but if it fails keep track here.
@@ skipping 18 matching lines @@
     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)

[Nico, 2016/05/27 13:09:33]

You removed this here but not in the cc file. So now the function is declared
but not defined in non-assert builds. Things generally build since nothing calls
this in non-assert builds -- but in release component builds the whole class is
exported and hence clients try to import this method and links fail
(https://build.chromium.org/p/chromium.fyi/builders/ClangToTWin%28dll%29/build...)

Rather than remove the ENABLE(ASSERT) in the cc file, I think it's better to add
it back here -- since things build, nothing needs this to be defined. And I
don't understand why you had to remove the #if in the other file.

     // 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*);
@@ skipping 16 matching lines @@
         ~OfflineGraphAutoLocker() { m_handler.unlock(); }
 
     private:
         DeferredTaskHandler& m_handler;
     };
 
 private:
     DeferredTaskHandler();
     void updateAutomaticPullNodes();
     void updateChangedChannelCountMode();
+    void updateChangedChannelInterpretation();
     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
     // copied from m_automaticPullNodes by updateAutomaticPullNodes() at the
     // very start or end of the rendering quantum.
     HashSet<AudioHandler*> m_automaticPullNodes;
     Vector<AudioHandler*> m_renderingAutomaticPullNodes;
     // m_automaticPullNodesNeedUpdating keeps track if m_automaticPullNodes is modified.
     bool m_automaticPullNodesNeedUpdating;
 
     // 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*> m_deferredCountModeChange;
 
+    HashSet<AudioHandler*> m_deferredChannelInterpretationChange;
+
     // 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*> m_dirtySummingJunctions;
     HashSet<AudioNodeOutput*> m_dirtyAudioNodeOutputs;
 
     // Only accessed in the audio thread.
     Vector<AudioHandler*> m_deferredBreakConnectionList;
 
     Vector<RefPtr<AudioHandler>> m_renderingOrphanHandlers;
     Vector<RefPtr<AudioHandler>> m_deletableOrphanHandlers;
 
     // Graph locking.
     RecursiveMutex m_contextGraphMutex;
     volatile ThreadIdentifier m_audioThread;
 };
 
 } // namespace blink
 
 #endif // DeferredTaskHandler_h