The Tor Browser: content/media/webaudio/AudioNode.h@97036ab72558 (annotated)

content/media/webaudio/AudioNode.h@97036ab72558 (annotated)

content/media/webaudio/AudioNode.h

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:set ts=2 sw=2 sts=2 et cindent: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef AudioNode_h_
 #define AudioNode_h_
 #include "mozilla/DOMEventTargetHelper.h"
 #include "mozilla/dom/AudioNodeBinding.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsAutoPtr.h"
 #include "nsTArray.h"
 #include "AudioContext.h"
 #include "MediaStreamGraph.h"
 #include "WebAudioUtils.h"
 #include "mozilla/MemoryReporting.h"
 namespace mozilla {
 namespace dom {
 class AudioContext;
 class AudioBufferSourceNode;
 class AudioParam;
 class AudioParamTimeline;
 struct ThreeDPoint;
 template<class T>
 class SelfReference {
 public:
   SelfReference() : mHeld(false) {}
   ~SelfReference()
   {
     NS_ASSERTION(!mHeld, "Forgot to drop the self reference?");
   }
   void Take(T* t)
   {
     if (!mHeld) {
       mHeld = true;
       t->AddRef();
     }
   }
   void Drop(T* t)
   {
     if (mHeld) {
       mHeld = false;
       t->Release();
     }
   }
   operator bool() const { return mHeld; }
 private:
   bool mHeld;
 };
 /**
  * The DOM object representing a Web Audio AudioNode.
  *
  * Each AudioNode has a MediaStream representing the actual
  * real-time processing and output of this AudioNode.
  *
  * We track the incoming and outgoing connections to other AudioNodes.
  * Outgoing connections have strong ownership.  Also, AudioNodes that will
  * produce sound on their output even when they have silent or no input ask
  * the AudioContext to keep playing or tail-time references to keep them alive
  * until the context is finished.
  *
  * Explicit disconnections will only remove references from output nodes after
  * the graph is notified and the main thread receives a reply.  Similarly,
  * nodes with playing or tail-time references release these references only
  * after receiving notification from their engine on the graph thread that
  * playing has stopped.  Engines notifying the main thread that they have
  * finished do so strictly *after* producing and returning their last block.
  * In this way, an engine that receives non-null input knows that the input
  * comes from nodes that are still alive and will keep their output nodes
  * alive for at least as long as it takes to process messages from the graph
  * thread.  i.e. the engine receiving non-null input knows that its node is
  * still alive, and will still be alive when it receives a message from the
  * engine.
  */
 class AudioNode : public DOMEventTargetHelper
 {
 protected:
   // You can only use refcounting to delete this object
   virtual ~AudioNode();
 public:
   AudioNode(AudioContext* aContext,
             uint32_t aChannelCount,
             ChannelCountMode aChannelCountMode,
             ChannelInterpretation aChannelInterpretation);
   // This should be idempotent (safe to call multiple times).
   virtual void DestroyMediaStream();
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(AudioNode,
                                            DOMEventTargetHelper)
   virtual AudioBufferSourceNode* AsAudioBufferSourceNode() {
     return nullptr;
   }
   virtual const DelayNode* AsDelayNode() const {
     return nullptr;
   }
   AudioContext* GetParentObject() const
   {
     return mContext;
   }
   AudioContext* Context() const
   {
     return mContext;
   }
   virtual void Connect(AudioNode& aDestination, uint32_t aOutput,
                        uint32_t aInput, ErrorResult& aRv);
   virtual void Connect(AudioParam& aDestination, uint32_t aOutput,
                        ErrorResult& aRv);
   virtual void Disconnect(uint32_t aOutput, ErrorResult& aRv);
   // The following two virtual methods must be implemented by each node type
   // to provide their number of input and output ports. These numbers are
   // constant for the lifetime of the node. Both default to 1.
   virtual uint16_t NumberOfInputs() const { return 1; }
   virtual uint16_t NumberOfOutputs() const { return 1; }
   uint32_t ChannelCount() const { return mChannelCount; }
   virtual void SetChannelCount(uint32_t aChannelCount, ErrorResult& aRv)
   {
     if (aChannelCount == 0 ||
         aChannelCount > WebAudioUtils::MaxChannelCount) {
       aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
       return;
     }
     mChannelCount = aChannelCount;
     SendChannelMixingParametersToStream();
   }
   ChannelCountMode ChannelCountModeValue() const
   {
     return mChannelCountMode;
   }
   virtual void SetChannelCountModeValue(ChannelCountMode aMode, ErrorResult& aRv)
   {
     mChannelCountMode = aMode;
     SendChannelMixingParametersToStream();
   }
   ChannelInterpretation ChannelInterpretationValue() const
   {
     return mChannelInterpretation;
   }
   void SetChannelInterpretationValue(ChannelInterpretation aMode)
   {
     mChannelInterpretation = aMode;
     SendChannelMixingParametersToStream();
   }
   struct InputNode {
     ~InputNode()
     {
       if (mStreamPort) {
         mStreamPort->Destroy();
       }
     }
     size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
     {
       size_t amount = 0;
       if (mStreamPort) {
         amount += mStreamPort->SizeOfIncludingThis(aMallocSizeOf);
       }
       return amount;
     }
     // Weak reference.
     AudioNode* mInputNode;
     nsRefPtr<MediaInputPort> mStreamPort;
     // The index of the input port this node feeds into.
     // This is not used for connections to AudioParams.
     uint32_t mInputPort;
     // The index of the output port this node comes out of.
     uint32_t mOutputPort;
   };
   MediaStream* Stream() { return mStream; }
   const nsTArray<InputNode>& InputNodes() const
   {
     return mInputNodes;
   }
   const nsTArray<nsRefPtr<AudioNode> >& OutputNodes() const
   {
     return mOutputNodes;
   }
   const nsTArray<nsRefPtr<AudioParam> >& OutputParams() const
   {
     return mOutputParams;
   }
   void RemoveOutputParam(AudioParam* aParam);
   // MarkActive() asks the context to keep the AudioNode alive until the
   // context is finished.  This takes care of "playing" references and
   // "tail-time" references.
   void MarkActive() { Context()->RegisterActiveNode(this); }
   // Active nodes call MarkInactive() when they have finished producing sound
   // for the foreseeable future.
   // Do not call MarkInactive from a node destructor.  If the destructor is
   // called, then the node is already inactive.
   // MarkInactive() may delete |this|.
   void MarkInactive() { Context()->UnregisterActiveNode(this); }
   virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const;
   virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
   virtual const char* NodeType() const = 0;
 private:
   friend class AudioBufferSourceNode;
   // This could possibly delete 'this'.
   void DisconnectFromGraph();
 protected:
   static void Callback(AudioNode* aNode) { /* not implemented */ }
   // Helpers for sending different value types to streams
   void SendDoubleParameterToStream(uint32_t aIndex, double aValue);
   void SendInt32ParameterToStream(uint32_t aIndex, int32_t aValue);
   void SendThreeDPointParameterToStream(uint32_t aIndex, const ThreeDPoint& aValue);
   void SendChannelMixingParametersToStream();
   static void SendTimelineParameterToStream(AudioNode* aNode, uint32_t aIndex,
                                             const AudioParamTimeline& aValue);
 private:
   nsRefPtr<AudioContext> mContext;
 protected:
   // Must be set in the constructor. Must not be null.
   // If MaxNumberOfInputs() is > 0, then mStream must be a ProcessedMediaStream.
   nsRefPtr<MediaStream> mStream;
 private:
   // For every InputNode, there is a corresponding entry in mOutputNodes of the
   // InputNode's mInputNode.
   nsTArray<InputNode> mInputNodes;
   // For every mOutputNode entry, there is a corresponding entry in mInputNodes
   // of the mOutputNode entry. We won't necessarily be able to identify the
   // exact matching entry, since mOutputNodes doesn't include the port
   // identifiers and the same node could be connected on multiple ports.
   nsTArray<nsRefPtr<AudioNode> > mOutputNodes;
   // For every mOutputParams entry, there is a corresponding entry in
   // AudioParam::mInputNodes of the mOutputParams entry. We won't necessarily be
   // able to identify the exact matching entry, since mOutputParams doesn't
   // include the port identifiers and the same node could be connected on
   // multiple ports.
   nsTArray<nsRefPtr<AudioParam> > mOutputParams;
   uint32_t mChannelCount;
   ChannelCountMode mChannelCountMode;
   ChannelInterpretation mChannelInterpretation;
 };
 }
 }
 #endif

The Tor Browser / annotate

content/media/webaudio/AudioNode.h@97036ab72558 (annotated)

content/media/webaudio/AudioNode.h