Revert CL 2242573002

third_party/WebKit/Source/modules/webaudio/AudioNode.cpp

 /*
  * 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 33 matching lines @@
     , m_node(&node)
     , m_context(node.context())
     , m_sampleRate(sampleRate)
     , m_lastProcessingTime(-1)
     , m_lastNonSilentTime(-1)
     , m_connectionRefCount(0)
     , m_isDisabled(false)
     , m_channelCount(2)
     , m_channelCountMode(Max)
     , m_channelInterpretation(AudioBus::Speakers)
+    , m_newChannelCountMode(Max)
 {
     setNodeType(nodeType);
 
 #if DEBUG_AUDIONODE_REFERENCES
     if (!s_isNodeCountInitialized) {
         s_isNodeCountInitialized = true;
         atexit(AudioHandler::printNodeCounts);
     }
 #endif
     InstanceCounters::incrementCounter(InstanceCounters::AudioHandlerCounter);
@@ skipping 24 matching lines @@
 
 void AudioHandler::clearInternalStateWhenDisabled()
 {
 }
 
 void AudioHandler::dispose()
 {
     DCHECK(isMainThread());
     ASSERT(context()->isGraphOwner());
 
+    context()->deferredTaskHandler().removeChangedChannelCountMode(this);
+    context()->deferredTaskHandler().removeChangedChannelInterpretation(this);
     context()->deferredTaskHandler().removeAutomaticPullNode(this);
     for (auto& output : m_outputs)
         output->dispose();
     m_node = nullptr;
 }
 
 AudioNode* AudioHandler::node() const
 {
     DCHECK(isMainThread());
     return m_node;
@@ skipping 96 matching lines @@
 }
 
 void AudioHandler::setChannelCount(unsigned long channelCount, ExceptionState& exceptionState)
 {
     DCHECK(isMainThread());
     BaseAudioContext::AutoLocker locker(context());
 
     if (channelCount > 0 && channelCount <= BaseAudioContext::maxNumberOfChannels()) {
         if (m_channelCount != channelCount) {
             m_channelCount = channelCount;
-            if (internalChannelCountMode() != Max)
+            if (m_channelCountMode != Max)
                 updateChannelsForInputs();
         }
     } else {
         exceptionState.throwDOMException(
             NotSupportedError,
             ExceptionMessages::indexOutsideRange<unsigned long>(
                 "channel count",
                 channelCount,
                 1,
                 ExceptionMessages::InclusiveBound,
                 BaseAudioContext::maxNumberOfChannels(),
                 ExceptionMessages::InclusiveBound));
     }
 }
 
 String AudioHandler::channelCountMode()
 {
-    switch (internalChannelCountMode()) {
+    switch (m_channelCountMode) {
     case Max:
         return "max";
     case ClampedMax:
         return "clamped-max";
     case Explicit:
         return "explicit";
     }
     ASSERT_NOT_REACHED();
     return "";
 }
 
 void AudioHandler::setChannelCountMode(const String& mode, ExceptionState& exceptionState)
 {
     DCHECK(isMainThread());
     BaseAudioContext::AutoLocker locker(context());
 
+    ChannelCountMode oldMode = m_channelCountMode;
+
     if (mode == "max") {
-        setInternalChannelCountMode(Max);
+        m_newChannelCountMode = Max;
     } else if (mode == "clamped-max") {
-        setInternalChannelCountMode(ClampedMax);
+        m_newChannelCountMode = ClampedMax;
     } else if (mode == "explicit") {
-        setInternalChannelCountMode(Explicit);
+        m_newChannelCountMode = Explicit;
     } else {
         ASSERT_NOT_REACHED();
     }
 
-    // Changing the channel count mode can affect the number of output channels;
-    // Propagate this change.
-    updateChannelsForInputs();
+    if (m_newChannelCountMode != oldMode)
+        context()->deferredTaskHandler().addChangedChannelCountMode(this);
 }
 
 String AudioHandler::channelInterpretation()
 {
-    switch (internalChannelInterpretation()) {
+    switch (m_channelInterpretation) {
     case AudioBus::Speakers:
         return "speakers";
     case AudioBus::Discrete:
         return "discrete";
     }
     ASSERT_NOT_REACHED();
     return "";
 }
 
 void AudioHandler::setChannelInterpretation(const String& interpretation, ExceptionState& exceptionState)
 {
     DCHECK(isMainThread());
     BaseAudioContext::AutoLocker locker(context());
 
+    AudioBus::ChannelInterpretation oldMode = m_channelInterpretation;
+
     if (interpretation == "speakers") {
-        setInternalChannelInterpretation(AudioBus::Speakers);
+        m_newChannelInterpretation = AudioBus::Speakers;
     } else if (interpretation == "discrete") {
-        setInternalChannelInterpretation(AudioBus::Discrete);
+        m_newChannelInterpretation = AudioBus::Discrete;
     } else {
         ASSERT_NOT_REACHED();
     }
 
-    // Changing the channel interpretation doesn't change the number of output
-    // channels, so we don't need to do any update here. The contents of each
-    // channel may change, of course, but that doesn't require updating the
-    // nodes for a different number of channels.
+    if (m_newChannelInterpretation != oldMode)
+        context()->deferredTaskHandler().addChangedChannelInterpretation(this);
 }
 
 void AudioHandler::updateChannelsForInputs()
 {
     for (auto& input : m_inputs)
         input->changedOutputs();
 }
 
 void AudioHandler::processIfNecessary(size_t framesToProcess)
 {
@@ skipping 193 matching lines @@
     fprintf(stderr, "===========================\n");
 
     for (unsigned i = 0; i < NodeTypeEnd; ++i)
         fprintf(stderr, "%2d: %d\n", i, s_nodeCount[i]);
 
     fprintf(stderr, "===========================\n\n\n");
 }
 
 #endif // DEBUG_AUDIONODE_REFERENCES
 
+void AudioHandler::updateChannelCountMode()
+{
+    m_channelCountMode = m_newChannelCountMode;
+    updateChannelsForInputs();
+}
+
+void AudioHandler::updateChannelInterpretation()
+{
+    m_channelInterpretation = m_newChannelInterpretation;
+}
+
 unsigned AudioHandler::numberOfOutputChannels() const
 {
     // This should only be called for ScriptProcessorNodes which are the only nodes where you can
     // have an output with 0 channels.  All other nodes have have at least one output channel, so
     // there's no reason other nodes should ever call this function.
     DCHECK(0) << "numberOfOutputChannels() not valid for node type " << getNodeType();
     return 1;
 }
 // ----------------------------------------------------------------
 
@@ skipping 423 matching lines @@
 void AudioNode::didAddOutput(unsigned numberOfOutputs)
 {
     m_connectedNodes.append(nullptr);
     DCHECK_EQ(numberOfOutputs, m_connectedNodes.size());
     m_connectedParams.append(nullptr);
     DCHECK_EQ(numberOfOutputs, m_connectedParams.size());
 }
 
 } // namespace blink