Return the correct channelCountMode and channelInterpretation

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 31 matching lines @@
     : m_isInitialized(false)
     , m_nodeType(NodeTypeUnknown)
     , 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);
+    setInternalChannelCountMode(Max);
+    setInternalChannelInterpretation(AudioBus::Speakers);
 
 #if DEBUG_AUDIONODE_REFERENCES
     if (!s_isNodeCountInitialized) {
         s_isNodeCountInitialized = true;
         atexit(AudioHandler::printNodeCounts);
     }
 #endif
     InstanceCounters::incrementCounter(InstanceCounters::AudioHandlerCounter);
 }
 
 AudioHandler::~AudioHandler()
 {
     DCHECK(isMainThread());
     // dispose() should be called.
     DCHECK(!node());
     InstanceCounters::decrementCounter(InstanceCounters::AudioHandlerCounter);
 #if DEBUG_AUDIONODE_REFERENCES
     --s_nodeCount[getNodeType()];
     fprintf(stderr, "[%16p]: %16p: %2d: AudioHandler::~AudioHandler() %d [%d]\n",
         context(), this, getNodeType(), m_connectionRefCount, s_nodeCount[getNodeType()]);
 #endif
 }
 
 void AudioHandler::initialize()
 {
+    DCHECK_EQ(m_newChannelCountMode, m_channelCountMode);
+    DCHECK_EQ(m_newChannelInterpretation, m_channelInterpretation);
+
     m_isInitialized = true;
 }
 
 void AudioHandler::uninitialize()
 {
     m_isInitialized = false;
 }
 
 void AudioHandler::clearInternalStateWhenDisabled()
 {
@@ skipping 107 matching lines @@
 AudioNodeOutput& AudioHandler::output(unsigned i)
 {
     return *m_outputs[i];
 }
 
 unsigned long AudioHandler::channelCount()
 {
     return m_channelCount;
 }
 
+void AudioHandler::setInternalChannelCountMode(ChannelCountMode mode)
+{
+    m_channelCountMode = mode;
+    m_newChannelCountMode = mode;
+}
+
+void AudioHandler::setInternalChannelInterpretation(AudioBus::ChannelInterpretation interpretation)
+{
+    m_channelInterpretation = interpretation;
+    m_newChannelInterpretation = interpretation;
+}
+
 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 (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 (m_channelCountMode) {
+    // Because we delay the actual setting of the mode to the pre or post
+    // rendering phase, we want to return the value that was set, not the actual
+    // current mode.
+    switch (m_newChannelCountMode) {
     case Max:
         return "max";
     case ClampedMax:
         return "clamped-max";
     case Explicit:
         return "explicit";
     }
     ASSERT_NOT_REACHED();
     return "";
 }
@@ skipping 14 matching lines @@
     } else {
         ASSERT_NOT_REACHED();
     }
 
     if (m_newChannelCountMode != oldMode)
         context()->deferredTaskHandler().addChangedChannelCountMode(this);
 }
 
 String AudioHandler::channelInterpretation()
 {
-    switch (m_channelInterpretation) {
+    // Because we delay the actual setting of the interpreation to the pre or
+    // post rendering phase, we want to return the value that was set, not the
+    // actual current interpretation.
+    switch (m_newChannelInterpretation) {
     case AudioBus::Speakers:
         return "speakers";
     case AudioBus::Discrete:
         return "discrete";
     }
     ASSERT_NOT_REACHED();
     return "";
 }
 
 void AudioHandler::setChannelInterpretation(const String& interpretation, ExceptionState& exceptionState)
@@ skipping 673 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