Enable Oilpan by default for webaudio/

Source/modules/webaudio/AudioNode.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 32 matching lines @@
 class AudioParam;
 class ExceptionState;
 
 // An AudioNode is the basic building block for handling audio within an AudioContext.
 // It may be an audio source, an intermediate processing module, or an audio destination.
 // Each AudioNode can have inputs and/or outputs. An AudioSourceNode has no inputs and a single output.
 // An AudioDestinationNode has one input and no outputs and represents the final destination to the audio hardware.
 // Most processing nodes such as filters will have one input and one output, although multiple inputs and outputs are possible.
 
 // AudioNode has its own ref-counting mechanism that use RefTypes so we cannot use RefCountedGarbageCollected.
-class AudioNode : public NoBaseWillBeGarbageCollectedFinalized<AudioNode>, public EventTargetWithInlineData {
+class AudioNode : public GarbageCollectedFinalized<AudioNode>, public EventTargetWithInlineData {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(AudioNode);
 public:
     enum { ProcessingSizeInFrames = 128 };
 
     AudioNode(AudioContext*, float sampleRate);
     virtual ~AudioNode();
     // dispose() is called just before the destructor. This must be called in
     // the main thread, and while the graph lock is held.
     virtual void dispose();
     static unsigned instanceCount() { return s_instanceCount; }
@@ skipping 26 matching lines @@
     enum ChannelCountMode {
         Max,
         ClampedMax,
         Explicit
     };
 
     NodeType nodeType() const { return m_nodeType; }
     String nodeTypeName() const;
     void setNodeType(NodeType);
 
-#if !ENABLE(OILPAN)
-    // Can be called from main thread or context's audio thread.
-    void ref();
-    void deref();
-#endif
-
     // This object has been connected to another object. This might have
     // existing connections from others.
     // This function must be called after acquiring a connection reference.
     void makeConnection();
     // This object will be disconnected from another object. This might have
     // remaining connections from others.
     // This function must be called before releasing a connection reference.
     void breakConnection();
 
     // Can be called from main thread or context's audio thread.  It must be called while the context's graph lock is held.
@@ skipping 75 matching lines @@
 
     // EventTarget
     virtual const AtomicString& interfaceName() const OVERRIDE FINAL;
     virtual ExecutionContext* executionContext() const OVERRIDE FINAL;
 
     virtual void trace(Visitor*) OVERRIDE;
 
 protected:
     // Inputs and outputs must be created before the AudioNode is initialized.
     void addInput();
-    void addOutput(PassOwnPtrWillBeRawPtr<AudioNodeOutput>);
+    void addOutput(AudioNodeOutput*);
 
     // Called by processIfNecessary() to cause all parts of the rendering graph connected to us to process.
     // Each rendering quantum, the audio data for each of the AudioNode's inputs will be available after this method is called.
     // Called from context's audio thread.
     virtual void pullInputs(size_t framesToProcess);
 
     // Force all inputs to take any channel interpretation changes into account.
     void updateChannelsForInputs();
 
 private:
     volatile bool m_isInitialized;
     NodeType m_nodeType;
-    RefPtrWillBeMember<AudioContext> m_context;
+    Member<AudioContext> m_context;
     float m_sampleRate;
-    WillBeHeapVector<OwnPtrWillBeMember<AudioNodeInput> > m_inputs;
-    WillBeHeapVector<OwnPtrWillBeMember<AudioNodeOutput> > m_outputs;
+    HeapVector<Member<AudioNodeInput> > m_inputs;
+    HeapVector<Member<AudioNodeOutput> > m_outputs;
 
     double m_lastProcessingTime;
     double m_lastNonSilentTime;
 
 #if !ENABLE(OILPAN)
     // Ref-counting
     volatile int m_normalRefCount;
+
+    // AudioNodes are in the oilpan heap but they are still reference counted at
+    // the same time. This is because we are not allowed to stop the audio
+    // thread and thus the audio thread cannot allocate objects in the oilpan
+    // heap.
+    // The m_keepAlive handle is used to keep a persistent reference to this
+    // AudioNode while someone has a reference to this AudioNode through a
+    // RefPtr.
+    GC_PLUGIN_IGNORE("")
+    Persistent<AudioNode> m_keepAlive;
 #endif
     volatile int m_connectionRefCount;
 
     bool m_isDisabled;
     bool m_isDisposeCalled;
 
 #if DEBUG_AUDIONODE_REFERENCES
     static bool s_isNodeCountInitialized;
     static int s_nodeCount[NodeTypeEnd];
 #endif
     static unsigned s_instanceCount;
 
 #if !ENABLE(OILPAN)
+    // Can be called from main thread or context's audio thread.
+    void ref();
+    void deref();
+
     virtual void refEventTarget() OVERRIDE FINAL { ref(); }
     virtual void derefEventTarget() OVERRIDE FINAL { deref(); }
 #endif
 
 protected:
     unsigned m_channelCount;
     ChannelCountMode m_channelCountMode;
     AudioBus::ChannelInterpretation m_channelInterpretation;
 };
 
 } // namespace blink
 
 #endif // AudioNode_h