The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/

 /* 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 "DOMMediaStream.h"

 #include "nsContentUtils.h"

 #include "mozilla/dom/MediaStreamBinding.h"

 #include "mozilla/dom/LocalMediaStreamBinding.h"

 #include "mozilla/dom/AudioNode.h"

 #include "MediaStreamGraph.h"

 #include "AudioStreamTrack.h"

 #include "VideoStreamTrack.h"

 using namespace mozilla;

 using namespace mozilla::dom;

 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMMediaStream)

   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY

   NS_INTERFACE_MAP_ENTRY(nsISupports)

   NS_INTERFACE_MAP_ENTRY(nsIDOMMediaStream)

 NS_INTERFACE_MAP_END

 NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMMediaStream)

 NS_IMPL_CYCLE_COLLECTING_RELEASE(DOMMediaStream)

 NS_IMPL_CYCLE_COLLECTION_CLASS(DOMMediaStream)

 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(DOMMediaStream)

   tmp->Destroy();

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindow)

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mTracks)

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mConsumersToKeepAlive)

   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER

 NS_IMPL_CYCLE_COLLECTION_UNLINK_END

 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(DOMMediaStream)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTracks)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mConsumersToKeepAlive)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS

 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

 NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(DOMMediaStream)

 NS_IMPL_ISUPPORTS_INHERITED(DOMLocalMediaStream, DOMMediaStream,

                             nsIDOMLocalMediaStream)

 NS_IMPL_CYCLE_COLLECTION_INHERITED(DOMAudioNodeMediaStream, DOMMediaStream,

                                    mStreamNode)

 NS_IMPL_ADDREF_INHERITED(DOMAudioNodeMediaStream, DOMMediaStream)

 NS_IMPL_RELEASE_INHERITED(DOMAudioNodeMediaStream, DOMMediaStream)

 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(DOMAudioNodeMediaStream)

 NS_INTERFACE_MAP_END_INHERITING(DOMMediaStream)

 class DOMMediaStream::StreamListener : public MediaStreamListener {

 public:

   StreamListener(DOMMediaStream* aStream)

     : mStream(aStream)

   {}

   // Main thread only

   void Forget() { mStream = nullptr; }

   DOMMediaStream* GetStream() { return mStream; }

   class TrackChange : public nsRunnable {

   public:

     TrackChange(StreamListener* aListener,

                 TrackID aID, TrackTicks aTrackOffset,

                 uint32_t aEvents, MediaSegment::Type aType)

       : mListener(aListener), mID(aID), mEvents(aEvents), mType(aType)

     {

     }

     NS_IMETHOD Run()

     {

       NS_ASSERTION(NS_IsMainThread(), "main thread only");

       DOMMediaStream* stream = mListener->GetStream();

       if (!stream) {

         return NS_OK;

       }

       nsRefPtr<MediaStreamTrack> track;

       if (mEvents & MediaStreamListener::TRACK_EVENT_CREATED) {

         track = stream->CreateDOMTrack(mID, mType);

       } else {

         track = stream->GetDOMTrackFor(mID);

       }

       if (mEvents & MediaStreamListener::TRACK_EVENT_ENDED) {

         track->NotifyEnded();

       }

       return NS_OK;

     }

     StreamTime mEndTime;

     nsRefPtr<StreamListener> mListener;

     TrackID mID;

     uint32_t mEvents;

     MediaSegment::Type mType;

   };

   /**

    * Notify that changes to one of the stream tracks have been queued.

    * aTrackEvents can be any combination of TRACK_EVENT_CREATED and

    * TRACK_EVENT_ENDED. aQueuedMedia is the data being added to the track

    * at aTrackOffset (relative to the start of the stream).

    * aQueuedMedia can be null if there is no output.

    */

   virtual void NotifyQueuedTrackChanges(MediaStreamGraph* aGraph, TrackID aID,

                                         TrackRate aTrackRate,

                                         TrackTicks aTrackOffset,

                                         uint32_t aTrackEvents,

                                         const MediaSegment& aQueuedMedia) MOZ_OVERRIDE

   {

     if (aTrackEvents & (TRACK_EVENT_CREATED | TRACK_EVENT_ENDED)) {

       nsRefPtr<TrackChange> runnable =

         new TrackChange(this, aID, aTrackOffset, aTrackEvents,

                         aQueuedMedia.GetType());

       NS_DispatchToMainThread(runnable);

     }

   }

 private:

   // These fields may only be accessed on the main thread

   DOMMediaStream* mStream;

 };

 DOMMediaStream::DOMMediaStream()

   : mLogicalStreamStartTime(0),

     mStream(nullptr), mHintContents(0), mTrackTypesAvailable(0),

     mNotifiedOfMediaStreamGraphShutdown(false)

 {

   SetIsDOMBinding();

 }

 DOMMediaStream::~DOMMediaStream()

 {

   Destroy();

 }

 void

 DOMMediaStream::Destroy()

 {

   if (mListener) {

     mListener->Forget();

     mListener = nullptr;

   }

   if (mStream) {

     mStream->Destroy();

     mStream = nullptr;

   }

 }

 JSObject*

 DOMMediaStream::WrapObject(JSContext* aCx)

 {

   return dom::MediaStreamBinding::Wrap(aCx, this);

 }

 double

 DOMMediaStream::CurrentTime()

 {

   if (!mStream) {

     return 0.0;

   }

   return MediaTimeToSeconds(mStream->GetCurrentTime() - mLogicalStreamStartTime);

 }

 void

 DOMMediaStream::GetAudioTracks(nsTArray<nsRefPtr<AudioStreamTrack> >& aTracks)

 {

   for (uint32_t i = 0; i < mTracks.Length(); ++i) {

     AudioStreamTrack* t = mTracks[i]->AsAudioStreamTrack();

     if (t) {

       aTracks.AppendElement(t);

     }

   }

 }

 void

 DOMMediaStream::GetVideoTracks(nsTArray<nsRefPtr<VideoStreamTrack> >& aTracks)

 {

   for (uint32_t i = 0; i < mTracks.Length(); ++i) {

     VideoStreamTrack* t = mTracks[i]->AsVideoStreamTrack();

     if (t) {

       aTracks.AppendElement(t);

     }

   }

 }

 bool

 DOMMediaStream::IsFinished()

 {

   return !mStream || mStream->IsFinished();

 }

 void

 DOMMediaStream::InitSourceStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents)

 {

   mWindow = aWindow;

   SetHintContents(aHintContents);

   MediaStreamGraph* gm = MediaStreamGraph::GetInstance();

   InitStreamCommon(gm->CreateSourceStream(this));

 }

 void

 DOMMediaStream::InitTrackUnionStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents)

 {

   mWindow = aWindow;

   SetHintContents(aHintContents);

   MediaStreamGraph* gm = MediaStreamGraph::GetInstance();

   InitStreamCommon(gm->CreateTrackUnionStream(this));

 }

 void

 DOMMediaStream::InitStreamCommon(MediaStream* aStream)

 {

   mStream = aStream;

   // Setup track listener

   mListener = new StreamListener(this);

   aStream->AddListener(mListener);

 }

 already_AddRefed<DOMMediaStream>

 DOMMediaStream::CreateSourceStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents)

 {

   nsRefPtr<DOMMediaStream> stream = new DOMMediaStream();

   stream->InitSourceStream(aWindow, aHintContents);

   return stream.forget();

 }

 already_AddRefed<DOMMediaStream>

 DOMMediaStream::CreateTrackUnionStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents)

 {

   nsRefPtr<DOMMediaStream> stream = new DOMMediaStream();

   stream->InitTrackUnionStream(aWindow, aHintContents);

   return stream.forget();

 }

 void

 DOMMediaStream::SetTrackEnabled(TrackID aTrackID, bool aEnabled)

 {

   if (mStream) {

     mStream->SetTrackEnabled(aTrackID, aEnabled);

   }

 }

 bool

 DOMMediaStream::CombineWithPrincipal(nsIPrincipal* aPrincipal)

 {

   return nsContentUtils::CombineResourcePrincipals(&mPrincipal, aPrincipal);

 }

 MediaStreamTrack*

 DOMMediaStream::CreateDOMTrack(TrackID aTrackID, MediaSegment::Type aType)

 {

   MediaStreamTrack* track;

   switch (aType) {

   case MediaSegment::AUDIO:

     track = new AudioStreamTrack(this, aTrackID);

     mTrackTypesAvailable |= HINT_CONTENTS_AUDIO;

     break;

   case MediaSegment::VIDEO:

     track = new VideoStreamTrack(this, aTrackID);

     mTrackTypesAvailable |= HINT_CONTENTS_VIDEO;

     break;

   default:

     MOZ_CRASH("Unhandled track type");

   }

   mTracks.AppendElement(track);

   CheckTracksAvailable();

   return track;

 }

 MediaStreamTrack*

 DOMMediaStream::GetDOMTrackFor(TrackID aTrackID)

 {

   for (uint32_t i = 0; i < mTracks.Length(); ++i) {

     MediaStreamTrack* t = mTracks[i];

     // We may add streams to our track list that are actually owned by

     // a different DOMMediaStream. Ignore those.

     if (t->GetTrackID() == aTrackID && t->GetStream() == this) {

       return t;

     }

   }

   return nullptr;

 }

 void

 DOMMediaStream::NotifyMediaStreamGraphShutdown()

 {

   // No more tracks will ever be added, so just clear these callbacks now

   // to prevent leaks.

   mNotifiedOfMediaStreamGraphShutdown = true;

   mRunOnTracksAvailable.Clear();

   mConsumersToKeepAlive.Clear();

 }

 void

 DOMMediaStream::NotifyStreamStateChanged()

 {

   if (IsFinished()) {

     mConsumersToKeepAlive.Clear();

   }

 }

 void

 DOMMediaStream::OnTracksAvailable(OnTracksAvailableCallback* aRunnable)

 {

   if (mNotifiedOfMediaStreamGraphShutdown) {

     // No more tracks will ever be added, so just delete the callback now.

     delete aRunnable;

     return;

   }

   mRunOnTracksAvailable.AppendElement(aRunnable);

   CheckTracksAvailable();

 }

 void

 DOMMediaStream::CheckTracksAvailable()

 {

   if (mTrackTypesAvailable == 0) {

     return;

   }

   nsTArray<nsAutoPtr<OnTracksAvailableCallback> > callbacks;

   callbacks.SwapElements(mRunOnTracksAvailable);

   for (uint32_t i = 0; i < callbacks.Length(); ++i) {

     OnTracksAvailableCallback* cb = callbacks[i];

     if (~mTrackTypesAvailable & cb->GetExpectedTracks()) {

       // Some expected tracks not available yet. Try this callback again later.

       *mRunOnTracksAvailable.AppendElement() = callbacks[i].forget();

       continue;

     }

     cb->NotifyTracksAvailable(this);

   }

 }

 DOMLocalMediaStream::~DOMLocalMediaStream()

 {

   if (mStream) {

     // Make sure Listeners of this stream know it's going away

     Stop();

   }

 }

 JSObject*

 DOMLocalMediaStream::WrapObject(JSContext* aCx)

 {

   return dom::LocalMediaStreamBinding::Wrap(aCx, this);

 }

 void

 DOMLocalMediaStream::Stop()

 {

   if (mStream && mStream->AsSourceStream()) {

     mStream->AsSourceStream()->EndAllTrackAndFinish();

   }

 }

 already_AddRefed<DOMLocalMediaStream>

 DOMLocalMediaStream::CreateSourceStream(nsIDOMWindow* aWindow,

                                         TrackTypeHints aHintContents)

 {

   nsRefPtr<DOMLocalMediaStream> stream = new DOMLocalMediaStream();

   stream->InitSourceStream(aWindow, aHintContents);

   return stream.forget();

 }

 already_AddRefed<DOMLocalMediaStream>

 DOMLocalMediaStream::CreateTrackUnionStream(nsIDOMWindow* aWindow,

                                             TrackTypeHints aHintContents)

 {

   nsRefPtr<DOMLocalMediaStream> stream = new DOMLocalMediaStream();

   stream->InitTrackUnionStream(aWindow, aHintContents);

   return stream.forget();

 }

 DOMAudioNodeMediaStream::DOMAudioNodeMediaStream(AudioNode* aNode)

 : mStreamNode(aNode)

 {

 }

 already_AddRefed<DOMAudioNodeMediaStream>

 DOMAudioNodeMediaStream::CreateTrackUnionStream(nsIDOMWindow* aWindow,

                                                 AudioNode* aNode,

                                                 TrackTypeHints aHintContents)

 {

   nsRefPtr<DOMAudioNodeMediaStream> stream = new DOMAudioNodeMediaStream(aNode);

   stream->InitTrackUnionStream(aWindow, aHintContents);

   return stream.forget();

 }