Implement BaseAudioContext

third_party/WebKit/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 21 matching lines @@
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 #include "wtf/build_config.h"
 
 #define DEBUG_AUDIONODE_REFERENCES 0
 
 namespace blink {
 
-class AbstractAudioContext;
+class BaseAudioContext;
 class AudioNode;
 class AudioNodeInput;
 class AudioNodeOutput;
 class AudioParam;
 class ExceptionState;
 
-// An AudioNode is the basic building block for handling audio within an AbstractAudioContext.
+// An AudioNode is the basic building block for handling audio within an BaseAudioContext.
 // 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.
 
 // Each of AudioNode objects owns its dedicated AudioHandler object. AudioNode
 // is responsible to provide IDL-accessible interface and its lifetime is
 // managed by Oilpan GC. AudioHandler is responsible for anything else. We must
 // not touch AudioNode objects in an audio rendering thread.
 
@@ skipping 38 matching lines @@
     // dispose() is called when the owner AudioNode is about to be
     // destructed. This must be called in the main thread, and while the graph
     // lock is held.
     // Do not release resources used by an audio rendering thread in dispose().
     virtual void dispose();
 
     // node() returns a valid object until dispose() is called.  This returns
     // nullptr after dispose().  We must not call node() in an audio rendering
     // thread.
     AudioNode* node() const;
-    // context() returns a valid object until the AbstractAudioContext dies, and returns
+    // context() returns a valid object until the BaseAudioContext dies, and returns
     // nullptr otherwise.  This always returns a valid object in an audio
     // rendering thread, and inside dispose().  We must not call context() in
     // the destructor.
-    virtual AbstractAudioContext* context() const;
+    virtual BaseAudioContext* context() const;
     void clearContext() { m_context = nullptr; }
 
     enum ChannelCountMode {
         Max,
         ClampedMax,
         Explicit
     };
 
     NodeType getNodeType() const { return m_nodeType; }
     String nodeTypeName() const;
@@ skipping 114 matching lines @@
     volatile bool m_isInitialized;
     NodeType m_nodeType;
 
     // The owner AudioNode.  This untraced member is safe because dispose() is
     // called before the AudioNode death, and it clears m_node.  Do not access
     // m_node directly, use node() instead.
     // See http://crbug.com/404527 for the detail.
     UntracedMember<AudioNode> m_node;
 
     // This untraced member is safe because this is cleared for all of live
-    // AudioHandlers when the AbstractAudioContext dies.  Do not access m_context
+    // AudioHandlers when the BaseAudioContext dies.  Do not access m_context
     // directly, use context() instead.
     // See http://crbug.com/404527 for the detail.
-    UntracedMember<AbstractAudioContext> m_context;
+    UntracedMember<BaseAudioContext> m_context;
 
     float m_sampleRate;
     Vector<OwnPtr<AudioNodeInput>> m_inputs;
     Vector<OwnPtr<AudioNodeOutput>> m_outputs;
 
     double m_lastProcessingTime;
     double m_lastNonSilentTime;
 
     volatile int m_connectionRefCount;
 
@@ skipping 23 matching lines @@
 
     virtual AudioNode* connect(AudioNode*, unsigned outputIndex, unsigned inputIndex, ExceptionState&);
     void connect(AudioParam*, unsigned outputIndex, ExceptionState&);
     void disconnect();
     virtual void disconnect(unsigned outputIndex, ExceptionState&);
     void disconnect(AudioNode*, ExceptionState&);
     void disconnect(AudioNode*, unsigned outputIndex, ExceptionState&);
     void disconnect(AudioNode*, unsigned outputIndex, unsigned inputIndex, ExceptionState&);
     void disconnect(AudioParam*, ExceptionState&);
     void disconnect(AudioParam*, unsigned outputIndex, ExceptionState&);
-    AbstractAudioContext* context() const;
+    BaseAudioContext* context() const;
     unsigned numberOfInputs() const;
     unsigned numberOfOutputs() const;
     unsigned long channelCount() const;
     void setChannelCount(unsigned long, ExceptionState&);
     String channelCountMode() const;
     void setChannelCountMode(const String&, ExceptionState&);
     String channelInterpretation() const;
     void setChannelInterpretation(const String&, ExceptionState&);
 
     // EventTarget
     const AtomicString& interfaceName() const final;
     ExecutionContext* getExecutionContext() const final;
 
     // Called inside AudioHandler constructors.
     void didAddOutput(unsigned numberOfOutputs);
     // Like disconnect, but no exception is thrown if the outputIndex is invalid.  Just do nothing
     // in that case.
     void disconnectWithoutException(unsigned outputIndex);
 
 protected:
-    explicit AudioNode(AbstractAudioContext&);
+    explicit AudioNode(BaseAudioContext&);
     // This should be called in a constructor.
     void setHandler(PassRefPtr<AudioHandler>);
 
 private:
     void dispose();
     void disconnectAllFromOutput(unsigned outputIndex);
     // Returns true if the specified AudioNodeInput was connected.
     bool disconnectFromOutputIfConnected(unsigned outputIndex, AudioNode& destination, unsigned inputIndexOfDestination);
     // Returns true if the specified AudioParam was connected.
     bool disconnectFromOutputIfConnected(unsigned outputIndex, AudioParam&);
 
-    Member<AbstractAudioContext> m_context;
+    Member<BaseAudioContext> m_context;
     RefPtr<AudioHandler> m_handler;
     // Represents audio node graph with Oilpan references. N-th HeapHashSet
     // represents a set of AudioNode objects connected to this AudioNode's N-th
     // output.
     HeapVector<Member<HeapHashSet<Member<AudioNode>>>> m_connectedNodes;
     // Represents audio node graph with Oilpan references. N-th HeapHashSet
     // represents a set of AudioParam objects connected to this AudioNode's N-th
     // output.
     HeapVector<Member<HeapHashSet<Member<AudioParam>>>> m_connectedParams;
 };
 
 } // namespace blink
 
 #endif // AudioNode_h