Enable Oilpan by default for webaudio/

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 34 matching lines @@
 
 unsigned AudioNode::s_instanceCount = 0;
 
 AudioNode::AudioNode(AudioContext* context, float sampleRate)
     : m_isInitialized(false)
     , m_nodeType(NodeTypeUnknown)
     , m_context(context)
     , m_sampleRate(sampleRate)
     , m_lastProcessingTime(-1)
     , m_lastNonSilentTime(-1)
-#if !ENABLE(OILPAN)
-    , m_normalRefCount(1) // start out with normal refCount == 1 (like WTF::RefCounted class)
-#endif
     , m_connectionRefCount(0)
     , m_isDisabled(false)
     , m_isDisposeCalled(false)
     , m_channelCount(2)
     , m_channelCountMode(Max)
     , m_channelInterpretation(AudioBus::Speakers)
 {
     ScriptWrappable::init(this);
-#if ENABLE(OILPAN)
     m_context->registerLiveNode(*this);
-#endif
 #if DEBUG_AUDIONODE_REFERENCES
     if (!s_isNodeCountInitialized) {
         s_isNodeCountInitialized = true;
         atexit(AudioNode::printNodeCounts);
     }
 #endif
     ++s_instanceCount;
 }
 
 AudioNode::~AudioNode()
 {
     ASSERT(m_isDisposeCalled);
     --s_instanceCount;
 #if DEBUG_AUDIONODE_REFERENCES
     --s_nodeCount[nodeType()];
-#if ENABLE(OILPAN)
     fprintf(stderr, "%p: %d: AudioNode::~AudioNode() %d\n", this, nodeType(), m_connectionRefCount);
-#else
-    fprintf(stderr, "%p: %d: AudioNode::~AudioNode() %d %d\n", this, nodeType(), m_normalRefCount, m_connectionRefCount);
-#endif
 #endif
 }
 
 void AudioNode::initialize()
 {
     m_isInitialized = true;
 }
 
 void AudioNode::uninitialize()
 {
@@ skipping 70 matching lines @@
 #if DEBUG_AUDIONODE_REFERENCES
     ++s_nodeCount[type];
 #endif
 }
 
 void AudioNode::addInput()
 {
     m_inputs.append(AudioNodeInput::create(*this));
 }
 
-void AudioNode::addOutput(PassOwnPtrWillBeRawPtr<AudioNodeOutput> output)
+void AudioNode::addOutput(AudioNodeOutput* output)
 {
     m_outputs.append(output);
 }
 
 AudioNodeInput* AudioNode::input(unsigned i)
 {
     if (i < m_inputs.size())
         return m_inputs[i].get();
     return 0;
 }
@@ skipping 276 matching lines @@
 
         m_isDisabled = false;
         for (unsigned i = 0; i < m_outputs.size(); ++i)
             output(i)->enable();
     }
 }
 
 void AudioNode::disableOutputsIfNecessary()
 {
     // Disable outputs if appropriate. We do this if the number of connections is 0 or 1. The case
-    // of 0 is from finishDeref() where there are no connections left. The case of 1 is from
+    // of 0 is from deref() where there are no connections left. The case of 1 is from
     // AudioNodeInput::disable() where we want to disable outputs when there's only one connection
     // left because we're ready to go away, but can't quite yet.
     if (m_connectionRefCount <= 1 && !m_isDisabled) {
         // Still may have JavaScript references, but no more "active" connection references, so put all of our outputs in a "dormant" disabled state.
         // Garbage collection may take a very long time after this time, so the "dormant" disabled nodes should not bog down the rendering...
 
         // As far as JavaScript is concerned, our outputs must still appear to be connected.
         // But internally our outputs should be disabled from the inputs they're connected to.
         // disable() can recursively deref connections (and call disable()) down a whole chain of connected nodes.
 
         // FIXME: we special case the convolver and delay since they have a significant tail-time and shouldn't be disconnected simply
         // because they no longer have any input connections. This needs to be handled more generally where AudioNodes have
         // a tailTime attribute. Then the AudioNode only needs to remain "active" for tailTime seconds after there are no
         // longer any active connections.
         if (nodeType() != NodeTypeConvolver && nodeType() != NodeTypeDelay) {
             m_isDisabled = true;
             for (unsigned i = 0; i < m_outputs.size(); ++i)
                 output(i)->disable();
         }
     }
 }
 
-#if !ENABLE(OILPAN)
-void AudioNode::ref()
-{
-    atomicIncrement(&m_normalRefCount);
-
-#if DEBUG_AUDIONODE_REFERENCES
-    fprintf(stderr, "%p: %d: AudioNode::ref() %d %d\n", this, nodeType(), m_normalRefCount, m_connectionRefCount);
-#endif
-}
-#endif
-
 void AudioNode::makeConnection()
 {
     atomicIncrement(&m_connectionRefCount);
-    // See the disabling code in finishDeref() below. This handles the case
-    // where a node is being re-connected after being used at least once and
-    // disconnected. In this case, we need to re-enable.
+    // See the disabling code in disableOutputsIfNecessary(). This handles
+    // the case where a node is being re-connected after being used at least
+    // once and disconnected. In this case, we need to re-enable.
     enableOutputsIfNecessary();
 }
 
-#if !ENABLE(OILPAN)
-void AudioNode::deref()
-{
-    // The actual work for deref happens completely within the audio context's
-    // graph lock. In the case of the audio thread, we must use a tryLock to
-    // avoid glitches.
-    bool hasLock = false;
-    bool mustReleaseLock = false;
-
-    if (context()->isAudioThread()) {
-        // Real-time audio thread must not contend lock (to avoid glitches).
-        hasLock = context()->tryLock(mustReleaseLock);
-    } else {
-        context()->lock(mustReleaseLock);
-        hasLock = true;
-    }
-
-    if (hasLock) {
-        // This is where the real deref work happens.
-        finishDeref();
-
-        if (mustReleaseLock)
-            context()->unlock();
-    } else {
-        // We were unable to get the lock, so put this in a list to finish up later.
-        ASSERT(context()->isAudioThread());
-        context()->addDeferredFinishDeref(this);
-    }
-
-    // Once AudioContext::uninitialize() is called there's no more chances for deleteMarkedNodes() to get called, so we call here.
-    // We can't call in AudioContext::~AudioContext() since it will never be called as long as any AudioNode is alive
-    // because AudioNodes keep a reference to the context.
-    if (!context()->isInitialized())
-        context()->deleteMarkedNodes();
-}
-#endif
-
 void AudioNode::breakConnection()
 {
     // The actual work for deref happens completely within the audio context's
     // graph lock. In the case of the audio thread, we must use a tryLock to
     // avoid glitches.
     bool hasLock = false;
     bool mustReleaseLock = false;
 
     if (context()->isAudioThread()) {
         // Real-time audio thread must not contend lock (to avoid glitches).
@@ skipping 12 matching lines @@
         // We were unable to get the lock, so put this in a list to finish up
         // later.
         ASSERT(context()->isAudioThread());
         context()->addDeferredBreakConnection(*this);
     }
 }
 
 void AudioNode::breakConnectionWithLock()
 {
     atomicDecrement(&m_connectionRefCount);
-#if !ENABLE(OILPAN)
-    ASSERT(m_normalRefCount > 0);
-#endif
     if (!m_connectionRefCount)
         disableOutputsIfNecessary();
 }
 
-#if !ENABLE(OILPAN)
-void AudioNode::finishDeref()
-{
-    ASSERT(context()->isGraphOwner());
-
-    ASSERT(m_normalRefCount > 0);
-    atomicDecrement(&m_normalRefCount);
-
-#if DEBUG_AUDIONODE_REFERENCES
-    fprintf(stderr, "%p: %d: AudioNode::deref() %d %d\n", this, nodeType(), m_normalRefCount, m_connectionRefCount);
-#endif
-
-    if (!m_normalRefCount) {
-        // Mark for deletion at end of each render quantum or when context shuts
-        // down.
-        context()->markForDeletion(this);
-    }
-}
-#endif
-
 #if DEBUG_AUDIONODE_REFERENCES
 
 bool AudioNode::s_isNodeCountInitialized = false;
 int AudioNode::s_nodeCount[NodeTypeEnd];
 
 void AudioNode::printNodeCounts()
 {
     fprintf(stderr, "\n\n");
     fprintf(stderr, "===========================\n");
     fprintf(stderr, "AudioNode: reference counts\n");
@@ skipping 11 matching lines @@
 {
     visitor->trace(m_context);
     visitor->trace(m_inputs);
     visitor->trace(m_outputs);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)