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 35 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)
+    // Start with 0, because we use m_normalRefCount only for ref() and deref()
+    // that are explicitly called. Other references are managed by Oilpan.
+    , m_normalRefCount(0)
 #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()
@@ skipping 90 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 302 matching lines @@
             m_isDisabled = true;
             for (unsigned i = 0; i < m_outputs.size(); ++i)
                 output(i)->disable();
         }
     }
 }
 
 #if !ENABLE(OILPAN)
 void AudioNode::ref()
 {
-    atomicIncrement(&m_normalRefCount);
+    // We create a self-keep-alive persistent handle when the first ref()
+    // is called.
+    if (atomicIncrement(&m_normalRefCount) == 1) {
+        ASSERT(!m_keepAlive);
+        m_keepAlive = this;
+    }
+    ASSERT(m_keepAlive);
 
 #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);
@@ skipping 24 matching lines @@
         // 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;
@@ skipping 15 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);
+        // This self-keep-alive handle can be resurrected when the ref() is
+        // called again.
+        m_keepAlive = nullptr;
     }
 }
 #endif
 
 #if DEBUG_AUDIONODE_REFERENCES
 
 bool AudioNode::s_isNodeCountInitialized = false;
 int AudioNode::s_nodeCount[NodeTypeEnd];
 
 void AudioNode::printNodeCounts()
@@ skipping 15 matching lines @@
 {
     visitor->trace(m_context);
     visitor->trace(m_inputs);
     visitor->trace(m_outputs);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)