The Tor Browser: content/media/webaudio/ScriptProcessorNode.cpp@97036ab72558 (annotated)

content/media/webaudio/ScriptProcessorNode.cpp@97036ab72558 (annotated)

content/media/webaudio/ScriptProcessorNode.cpp

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/. */
 #include "ScriptProcessorNode.h"
 #include "mozilla/dom/ScriptProcessorNodeBinding.h"
 #include "AudioBuffer.h"
 #include "AudioDestinationNode.h"
 #include "AudioNodeEngine.h"
 #include "AudioNodeStream.h"
 #include "AudioProcessingEvent.h"
 #include "WebAudioUtils.h"
 #include "nsCxPusher.h"
 #include "mozilla/Mutex.h"
 #include "mozilla/PodOperations.h"
 #include <deque>
 namespace mozilla {
 namespace dom {
 // The maximum latency, in seconds, that we can live with before dropping
 // buffers.
 static const float MAX_LATENCY_S = 0.5;
 NS_IMPL_ISUPPORTS_INHERITED0(ScriptProcessorNode, AudioNode)
 // This class manages a queue of output buffers shared between
 // the main thread and the Media Stream Graph thread.
 class SharedBuffers
 {
 private:
   class OutputQueue
   {
   public:
     explicit OutputQueue(const char* aName)
       : mMutex(aName)
     {}
     size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
     {
       mMutex.AssertCurrentThreadOwns();
       size_t amount = 0;
       for (size_t i = 0; i < mBufferList.size(); i++) {
         amount += mBufferList[i].SizeOfExcludingThis(aMallocSizeOf, false);
       }
       return amount;
     }
     Mutex& Lock() const { return const_cast<OutputQueue*>(this)->mMutex; }
     size_t ReadyToConsume() const
     {
       mMutex.AssertCurrentThreadOwns();
       MOZ_ASSERT(!NS_IsMainThread());
       return mBufferList.size();
     }
     // Produce one buffer
     AudioChunk& Produce()
     {
       mMutex.AssertCurrentThreadOwns();
       MOZ_ASSERT(NS_IsMainThread());
       mBufferList.push_back(AudioChunk());
       return mBufferList.back();
     }
     // Consumes one buffer.
     AudioChunk Consume()
     {
       mMutex.AssertCurrentThreadOwns();
       MOZ_ASSERT(!NS_IsMainThread());
       MOZ_ASSERT(ReadyToConsume() > 0);
       AudioChunk front = mBufferList.front();
       mBufferList.pop_front();
       return front;
     }
     // Empties the buffer queue.
     void Clear()
     {
       mMutex.AssertCurrentThreadOwns();
       mBufferList.clear();
     }
   private:
     typedef std::deque<AudioChunk> BufferList;
     // Synchronizes access to mBufferList.  Note that it's the responsibility
     // of the callers to perform the required locking, and we assert that every
     // time we access mBufferList.
     Mutex mMutex;
     // The list representing the queue.
     BufferList mBufferList;
   };
 public:
   SharedBuffers(float aSampleRate)
     : mOutputQueue("SharedBuffers::outputQueue")
     , mDelaySoFar(TRACK_TICKS_MAX)
     , mSampleRate(aSampleRate)
     , mLatency(0.0)
     , mDroppingBuffers(false)
   {
   }
   size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
   {
     size_t amount = aMallocSizeOf(this);
     {
       MutexAutoLock lock(mOutputQueue.Lock());
       amount += mOutputQueue.SizeOfExcludingThis(aMallocSizeOf);
     }
     return amount;
   }
   // main thread
   void FinishProducingOutputBuffer(ThreadSharedFloatArrayBufferList* aBuffer,
                                    uint32_t aBufferSize)
   {
     MOZ_ASSERT(NS_IsMainThread());
     TimeStamp now = TimeStamp::Now();
     if (mLastEventTime.IsNull()) {
       mLastEventTime = now;
     } else {
       // When the main thread is blocked, and all the event are processed in a
       // burst after the main thread unblocks, the |(now - mLastEventTime)|
       // interval will be very short. |latency - bufferDuration| will be
       // negative, effectively moving back mLatency to a smaller and smaller
       // value, until it crosses zero, at which point we stop dropping buffers
       // and resume normal operation. This does not work if at the same time,
       // the MSG thread was also slowed down, so if the latency on the MSG
       // thread is normal, and we are still dropping buffers, and mLatency is
       // still more than twice the duration of a buffer, we reset it and stop
       // dropping buffers.
       float latency = (now - mLastEventTime).ToSeconds();
       float bufferDuration = aBufferSize / mSampleRate;
       mLatency += latency - bufferDuration;
       mLastEventTime = now;
       if (mLatency > MAX_LATENCY_S ||
           (mDroppingBuffers && mLatency > 0.0 &&
            fabs(latency - bufferDuration) < bufferDuration)) {
         mDroppingBuffers = true;
         return;
       } else {
         if (mDroppingBuffers) {
           mLatency = 0;
         }
         mDroppingBuffers = false;
       }
     }
     MutexAutoLock lock(mOutputQueue.Lock());
     for (uint32_t offset = 0; offset < aBufferSize; offset += WEBAUDIO_BLOCK_SIZE) {
       AudioChunk& chunk = mOutputQueue.Produce();
       if (aBuffer) {
         chunk.mDuration = WEBAUDIO_BLOCK_SIZE;
         chunk.mBuffer = aBuffer;
         chunk.mChannelData.SetLength(aBuffer->GetChannels());
         for (uint32_t i = 0; i < aBuffer->GetChannels(); ++i) {
           chunk.mChannelData[i] = aBuffer->GetData(i) + offset;
         }
         chunk.mVolume = 1.0f;
         chunk.mBufferFormat = AUDIO_FORMAT_FLOAT32;
       } else {
         chunk.SetNull(WEBAUDIO_BLOCK_SIZE);
       }
     }
   }
   // graph thread
   AudioChunk GetOutputBuffer()
   {
     MOZ_ASSERT(!NS_IsMainThread());
     AudioChunk buffer;
     {
       MutexAutoLock lock(mOutputQueue.Lock());
       if (mOutputQueue.ReadyToConsume() > 0) {
         if (mDelaySoFar == TRACK_TICKS_MAX) {
           mDelaySoFar = 0;
         }
         buffer = mOutputQueue.Consume();
       } else {
         // If we're out of buffers to consume, just output silence
         buffer.SetNull(WEBAUDIO_BLOCK_SIZE);
         if (mDelaySoFar != TRACK_TICKS_MAX) {
           // Remember the delay that we just hit
           mDelaySoFar += WEBAUDIO_BLOCK_SIZE;
         }
       }
     }
     return buffer;
   }
   TrackTicks DelaySoFar() const
   {
     MOZ_ASSERT(!NS_IsMainThread());
     return mDelaySoFar == TRACK_TICKS_MAX ? 0 : mDelaySoFar;
   }
   void Reset()
   {
     MOZ_ASSERT(!NS_IsMainThread());
     mDelaySoFar = TRACK_TICKS_MAX;
     mLatency = 0.0f;
     {
       MutexAutoLock lock(mOutputQueue.Lock());
       mOutputQueue.Clear();
     }
     mLastEventTime = TimeStamp();
   }
 private:
   OutputQueue mOutputQueue;
   // How much delay we've seen so far.  This measures the amount of delay
   // caused by the main thread lagging behind in producing output buffers.
   // TRACK_TICKS_MAX means that we have not received our first buffer yet.
   TrackTicks mDelaySoFar;
   // The samplerate of the context.
   float mSampleRate;
   // This is the latency caused by the buffering. If this grows too high, we
   // will drop buffers until it is acceptable.
   float mLatency;
   // This is the time at which we last produced a buffer, to detect if the main
   // thread has been blocked.
   TimeStamp mLastEventTime;
   // True if we should be dropping buffers.
   bool mDroppingBuffers;
 };
 class ScriptProcessorNodeEngine : public AudioNodeEngine
 {
 public:
   typedef nsAutoTArray<nsAutoArrayPtr<float>, 2> InputChannels;
   ScriptProcessorNodeEngine(ScriptProcessorNode* aNode,
                             AudioDestinationNode* aDestination,
                             uint32_t aBufferSize,
                             uint32_t aNumberOfInputChannels)
     : AudioNodeEngine(aNode)
     , mSharedBuffers(aNode->GetSharedBuffers())
     , mSource(nullptr)
     , mDestination(static_cast<AudioNodeStream*> (aDestination->Stream()))
     , mBufferSize(aBufferSize)
     , mInputWriteIndex(0)
     , mSeenNonSilenceInput(false)
   {
     mInputChannels.SetLength(aNumberOfInputChannels);
     AllocateInputBlock();
   }
   void SetSourceStream(AudioNodeStream* aSource)
   {
     mSource = aSource;
   }
   virtual void ProcessBlock(AudioNodeStream* aStream,
                             const AudioChunk& aInput,
                             AudioChunk* aOutput,
                             bool* aFinished) MOZ_OVERRIDE
   {
     MutexAutoLock lock(NodeMutex());
     // If our node is dead, just output silence.
     if (!Node()) {
       aOutput->SetNull(WEBAUDIO_BLOCK_SIZE);
       return;
     }
     // This node is not connected to anything. Per spec, we don't fire the
     // onaudioprocess event. We also want to clear out the input and output
     // buffer queue, and output a null buffer.
     if (!(aStream->ConsumerCount() ||
           aStream->AsProcessedStream()->InputPortCount())) {
       aOutput->SetNull(WEBAUDIO_BLOCK_SIZE);
       mSharedBuffers->Reset();
       mSeenNonSilenceInput = false;
       mInputWriteIndex = 0;
       return;
     }
     // First, record our input buffer
     for (uint32_t i = 0; i < mInputChannels.Length(); ++i) {
       if (aInput.IsNull()) {
         PodZero(mInputChannels[i] + mInputWriteIndex,
                 aInput.GetDuration());
       } else {
         mSeenNonSilenceInput = true;
         MOZ_ASSERT(aInput.GetDuration() == WEBAUDIO_BLOCK_SIZE, "sanity check");
         MOZ_ASSERT(aInput.mChannelData.Length() == mInputChannels.Length());
         AudioBlockCopyChannelWithScale(static_cast<const float*>(aInput.mChannelData[i]),
                                        aInput.mVolume,
                                        mInputChannels[i] + mInputWriteIndex);
       }
     }
     mInputWriteIndex += aInput.GetDuration();
     // Now, see if we have data to output
     // Note that we need to do this before sending the buffer to the main
     // thread so that our delay time is updated.
     *aOutput = mSharedBuffers->GetOutputBuffer();
     if (mInputWriteIndex >= mBufferSize) {
       SendBuffersToMainThread(aStream);
       mInputWriteIndex -= mBufferSize;
       mSeenNonSilenceInput = false;
       AllocateInputBlock();
     }
   }
   virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
   {
     // Not owned:
     // - mSharedBuffers
     // - mSource (probably)
     // - mDestination (probably)
     size_t amount = AudioNodeEngine::SizeOfExcludingThis(aMallocSizeOf);
     amount += mInputChannels.SizeOfExcludingThis(aMallocSizeOf);
     for (size_t i = 0; i < mInputChannels.Length(); i++) {
       amount += mInputChannels[i].SizeOfExcludingThis(aMallocSizeOf);
     }
     return amount;
   }
   virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
   {
     return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
   }
 private:
   void AllocateInputBlock()
   {
     for (unsigned i = 0; i < mInputChannels.Length(); ++i) {
       if (!mInputChannels[i]) {
         mInputChannels[i] = new float[mBufferSize];
       }
     }
   }
   void SendBuffersToMainThread(AudioNodeStream* aStream)
   {
     MOZ_ASSERT(!NS_IsMainThread());
     // we now have a full input buffer ready to be sent to the main thread.
     TrackTicks playbackTick = mSource->GetCurrentPosition();
     // Add the duration of the current sample
     playbackTick += WEBAUDIO_BLOCK_SIZE;
     // Add the delay caused by the main thread
     playbackTick += mSharedBuffers->DelaySoFar();
     // Compute the playback time in the coordinate system of the destination
     // FIXME: bug 970773
     double playbackTime =
       mSource->DestinationTimeFromTicks(mDestination, playbackTick);
     class Command : public nsRunnable
     {
     public:
       Command(AudioNodeStream* aStream,
               InputChannels& aInputChannels,
               double aPlaybackTime,
               bool aNullInput)
         : mStream(aStream)
         , mPlaybackTime(aPlaybackTime)
         , mNullInput(aNullInput)
       {
         mInputChannels.SetLength(aInputChannels.Length());
         if (!aNullInput) {
           for (uint32_t i = 0; i < mInputChannels.Length(); ++i) {
             mInputChannels[i] = aInputChannels[i].forget();
           }
         }
       }
       NS_IMETHODIMP Run()
       {
         // If it's not safe to run scripts right now, schedule this to run later
         if (!nsContentUtils::IsSafeToRunScript()) {
           nsContentUtils::AddScriptRunner(this);
           return NS_OK;
         }
         nsRefPtr<ScriptProcessorNode> node;
         {
           // No need to keep holding the lock for the whole duration of this
           // function, since we're holding a strong reference to it, so if
           // we can obtain the reference, we will hold the node alive in
           // this function.
           MutexAutoLock lock(mStream->Engine()->NodeMutex());
           node = static_cast<ScriptProcessorNode*>(mStream->Engine()->Node());
         }
         if (!node || !node->Context()) {
           return NS_OK;
         }
         AutoPushJSContext cx(node->Context()->GetJSContext());
         if (cx) {
           // Create the input buffer
           nsRefPtr<AudioBuffer> inputBuffer;
           if (!mNullInput) {
             ErrorResult rv;
             inputBuffer =
               AudioBuffer::Create(node->Context(), mInputChannels.Length(),
                                   node->BufferSize(),
                                   node->Context()->SampleRate(), cx, rv);
             if (rv.Failed()) {
               return NS_OK;
             }
             // Put the channel data inside it
             for (uint32_t i = 0; i < mInputChannels.Length(); ++i) {
               inputBuffer->SetRawChannelContents(cx, i, mInputChannels[i]);
             }
           }
           // Ask content to produce data in the output buffer
           // Note that we always avoid creating the output buffer here, and we try to
           // avoid creating the input buffer as well.  The AudioProcessingEvent class
           // knows how to lazily create them if needed once the script tries to access
           // them.  Otherwise, we may be able to get away without creating them!
           nsRefPtr<AudioProcessingEvent> event = new AudioProcessingEvent(node, nullptr, nullptr);
           event->InitEvent(inputBuffer,
                            mInputChannels.Length(),
                            mPlaybackTime);
           node->DispatchTrustedEvent(event);
           // Steal the output buffers if they have been set.  Don't create a
           // buffer if it hasn't been used to return output;
           // FinishProducingOutputBuffer() will optimize output = null.
           // GetThreadSharedChannelsForRate() may also return null after OOM.
           nsRefPtr<ThreadSharedFloatArrayBufferList> output;
           if (event->HasOutputBuffer()) {
             ErrorResult rv;
             AudioBuffer* buffer = event->GetOutputBuffer(rv);
             // HasOutputBuffer() returning true means that GetOutputBuffer()
             // will not fail.
             MOZ_ASSERT(!rv.Failed());
             output = buffer->GetThreadSharedChannelsForRate(cx);
           }
           // Append it to our output buffer queue
           node->GetSharedBuffers()->FinishProducingOutputBuffer(output, node->BufferSize());
         }
         return NS_OK;
       }
     private:
       nsRefPtr<AudioNodeStream> mStream;
       InputChannels mInputChannels;
       double mPlaybackTime;
       bool mNullInput;
     };
     NS_DispatchToMainThread(new Command(aStream, mInputChannels,
                                         playbackTime,
                                         !mSeenNonSilenceInput));
   }
   friend class ScriptProcessorNode;
   SharedBuffers* mSharedBuffers;
   AudioNodeStream* mSource;
   AudioNodeStream* mDestination;
   InputChannels mInputChannels;
   const uint32_t mBufferSize;
   // The write index into the current input buffer
   uint32_t mInputWriteIndex;
   bool mSeenNonSilenceInput;
 };
 ScriptProcessorNode::ScriptProcessorNode(AudioContext* aContext,
                                          uint32_t aBufferSize,
                                          uint32_t aNumberOfInputChannels,
                                          uint32_t aNumberOfOutputChannels)
   : AudioNode(aContext,
               aNumberOfInputChannels,
               mozilla::dom::ChannelCountMode::Explicit,
               mozilla::dom::ChannelInterpretation::Speakers)
   , mSharedBuffers(new SharedBuffers(aContext->SampleRate()))
   , mBufferSize(aBufferSize ?
                   aBufferSize : // respect what the web developer requested
 )         // choose our own buffer size -- 4KB for now
   , mNumberOfOutputChannels(aNumberOfOutputChannels)
 {
   MOZ_ASSERT(BufferSize() % WEBAUDIO_BLOCK_SIZE == 0, "Invalid buffer size");
   ScriptProcessorNodeEngine* engine =
     new ScriptProcessorNodeEngine(this,
                                   aContext->Destination(),
                                   BufferSize(),
                                   aNumberOfInputChannels);
   mStream = aContext->Graph()->CreateAudioNodeStream(engine, MediaStreamGraph::INTERNAL_STREAM);
   engine->SetSourceStream(static_cast<AudioNodeStream*> (mStream.get()));
 }
 ScriptProcessorNode::~ScriptProcessorNode()
 {
 }
 size_t
 ScriptProcessorNode::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
 {
   size_t amount = AudioNode::SizeOfExcludingThis(aMallocSizeOf);
   amount += mSharedBuffers->SizeOfIncludingThis(aMallocSizeOf);
   return amount;
 }
 size_t
 ScriptProcessorNode::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
 {
   return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
 }
 JSObject*
 ScriptProcessorNode::WrapObject(JSContext* aCx)
 {
   return ScriptProcessorNodeBinding::Wrap(aCx, this);
 }
 }
 }

The Tor Browser / annotate

content/media/webaudio/ScriptProcessorNode.cpp@97036ab72558 (annotated)

content/media/webaudio/ScriptProcessorNode.cpp