The Tor Browser: media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h@ac0c01689b40

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

     1 /* This Source Code Form is subject to the terms of the Mozilla Public

     2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,

     3  * You can obtain one at http://mozilla.org/MPL/2.0/. */

     5 #ifndef _PEER_CONNECTION_IMPL_H_

     6 #define _PEER_CONNECTION_IMPL_H_

     8 #include <deque>

     9 #include <string>

    10 #include <vector>

    11 #include <map>

    12 #include <cmath>

    14 #include "prlock.h"

    15 #include "mozilla/RefPtr.h"

    16 #include "nsWeakPtr.h"

    17 #include "nsAutoPtr.h"

    18 #include "nsIWeakReferenceUtils.h" // for the definition of nsWeakPtr

    19 #include "IPeerConnection.h"

    20 #include "sigslot.h"

    21 #include "nricectx.h"

    22 #include "nricemediastream.h"

    23 #include "nsComponentManagerUtils.h"

    24 #include "nsPIDOMWindow.h"

    25 #include "nsIThread.h"

    27 #include "mozilla/ErrorResult.h"

    28 #include "mozilla/dom/PeerConnectionImplEnumsBinding.h"

    29 #include "StreamBuffer.h"

    30 #include "LoadManagerFactory.h"

    32 #ifdef MOZILLA_INTERNAL_API

    33 #include "mozilla/TimeStamp.h"

    34 #include "mozilla/net/DataChannel.h"

    35 #include "VideoUtils.h"

    36 #include "VideoSegment.h"

    37 #include "nsNSSShutDown.h"

    38 #include "mozilla/dom/RTCStatsReportBinding.h"

    39 #endif

    41 namespace test {

    42 #ifdef USE_FAKE_PCOBSERVER

    43 class AFakePCObserver;

    44 #endif

    45 }

    47 #ifdef USE_FAKE_MEDIA_STREAMS

    48 class Fake_DOMMediaStream;

    49 #endif

    51 class nsGlobalWindow;

    52 class nsIDOMMediaStream;

    53 class nsDOMDataChannel;

    55 namespace mozilla {

    56 class DataChannel;

    57 class DtlsIdentity;

    58 class NrIceCtx;

    59 class NrIceMediaStream;

    60 class NrIceStunServer;

    61 class NrIceTurnServer;

    62 class MediaPipeline;

    64 #ifdef USE_FAKE_MEDIA_STREAMS

    65 typedef Fake_DOMMediaStream DOMMediaStream;

    66 #else

    67 class DOMMediaStream;

    68 #endif

    70 namespace dom {

    71 class RTCConfiguration;

    72 class MediaConstraintsInternal;

    73 class MediaStreamTrack;

    74 class RTCStatsReportInternal;

    76 #ifdef USE_FAKE_PCOBSERVER

    77 typedef test::AFakePCObserver PeerConnectionObserver;

    78 typedef const char *PCObserverString;

    79 #else

    80 class PeerConnectionObserver;

    81 typedef NS_ConvertUTF8toUTF16 PCObserverString;

    82 #endif

    83 }

    84 class MediaConstraintsExternal;

    85 }

    87 #if defined(__cplusplus) && __cplusplus >= 201103L

    88 typedef struct Timecard Timecard;

    89 #else

    90 #include "timecard.h"

    91 #endif

    93 // To preserve blame, convert nsresult to ErrorResult with wrappers. These macros

    94 // help declare wrappers w/function being wrapped when there are no differences.

    96 #define NS_IMETHODIMP_TO_ERRORRESULT(func, rv, ...) \

    97 NS_IMETHODIMP func(__VA_ARGS__);                    \

    98 void func (__VA_ARGS__, rv)

   100 #define NS_IMETHODIMP_TO_ERRORRESULT_RETREF(resulttype, func, rv, ...) \

   101 NS_IMETHODIMP func(__VA_ARGS__, resulttype **result);                  \

   102 already_AddRefed<resulttype> func (__VA_ARGS__, rv)

   104 namespace sipcc {

   106 using mozilla::dom::PeerConnectionObserver;

   107 using mozilla::dom::RTCConfiguration;

   108 using mozilla::dom::MediaConstraintsInternal;

   109 using mozilla::MediaConstraintsExternal;

   110 using mozilla::DOMMediaStream;

   111 using mozilla::NrIceCtx;

   112 using mozilla::NrIceMediaStream;

   113 using mozilla::DtlsIdentity;

   114 using mozilla::ErrorResult;

   115 using mozilla::NrIceStunServer;

   116 using mozilla::NrIceTurnServer;

   118 class PeerConnectionWrapper;

   119 class PeerConnectionMedia;

   120 class RemoteSourceStreamInfo;

   121 class OnCallEventArgs;

   123 class IceConfiguration

   124 {

   125 public:

   126   bool addStunServer(const std::string& addr, uint16_t port)

   127   {

   128     NrIceStunServer* server(NrIceStunServer::Create(addr, port));

   129     if (!server) {

   130       return false;

   131     }

   132     addStunServer(*server);

   133     return true;

   134   }

   135   bool addTurnServer(const std::string& addr, uint16_t port,

   136                      const std::string& username,

   137                      const std::string& pwd,

   138                      const char* transport)

   139   {

   140     // TODO(ekr@rtfm.com): Need support for SASLprep for

   141     // username and password. Bug # ???

   142     std::vector<unsigned char> password(pwd.begin(), pwd.end());

   144     NrIceTurnServer* server(NrIceTurnServer::Create(addr, port, username, password,

   145                                                     transport));

   146     if (!server) {

   147       return false;

   148     }

   149     addTurnServer(*server);

   150     return true;

   151   }

   152   void addStunServer(const NrIceStunServer& server) { mStunServers.push_back (server); }

   153   void addTurnServer(const NrIceTurnServer& server) { mTurnServers.push_back (server); }

   154   const std::vector<NrIceStunServer>& getStunServers() const { return mStunServers; }

   155   const std::vector<NrIceTurnServer>& getTurnServers() const { return mTurnServers; }

   156 private:

   157   std::vector<NrIceStunServer> mStunServers;

   158   std::vector<NrIceTurnServer> mTurnServers;

   159 };

   161 #ifdef MOZILLA_INTERNAL_API

   162 // Not an inner class so we can forward declare.

   163 class RTCStatsQuery {

   164   public:

   165     explicit RTCStatsQuery(bool internalStats);

   166     ~RTCStatsQuery();

   168     mozilla::dom::RTCStatsReportInternal report;

   169     std::string error;

   171   private:

   172     friend class PeerConnectionImpl;

   173     std::string pcName;

   174     bool internalStats;

   175     nsTArray<mozilla::RefPtr<mozilla::MediaPipeline>> pipelines;

   176     mozilla::RefPtr<NrIceCtx> iceCtx;

   177     nsTArray<mozilla::RefPtr<NrIceMediaStream>> streams;

   178     DOMHighResTimeStamp now;

   179 };

   180 #endif // MOZILLA_INTERNAL_API

   182 // Enter an API call and check that the state is OK,

   183 // the PC isn't closed, etc.

   184 #define PC_AUTO_ENTER_API_CALL(assert_ice_ready) \

   185     do { \

   186       /* do/while prevents res from conflicting with locals */    \

   187       nsresult res = CheckApiState(assert_ice_ready);             \

   188       if (NS_FAILED(res)) return res; \

   189     } while(0)

   190 #define PC_AUTO_ENTER_API_CALL_VOID_RETURN(assert_ice_ready) \

   191     do { \

   192       /* do/while prevents res from conflicting with locals */    \

   193       nsresult res = CheckApiState(assert_ice_ready);             \

   194       if (NS_FAILED(res)) return; \

   195     } while(0)

   196 #define PC_AUTO_ENTER_API_CALL_NO_CHECK() CheckThread()

   198 class PeerConnectionImpl MOZ_FINAL : public nsISupports,

   199 #ifdef MOZILLA_INTERNAL_API

   200                                      public mozilla::DataChannelConnection::DataConnectionListener,

   201                                      public nsNSSShutDownObject,

   202 #endif

   203                                      public sigslot::has_slots<>

   204 {

   205   class Internal; // Avoid exposing c includes to bindings

   207 public:

   208   PeerConnectionImpl(const mozilla::dom::GlobalObject* aGlobal = nullptr);

   209   virtual ~PeerConnectionImpl();

   211   enum Error {

   212     kNoError                          = 0,

   213     kInvalidConstraintsType           = 1,

   214     kInvalidCandidateType             = 2,

   215     kInvalidMediastreamTrack          = 3,

   216     kInvalidState                     = 4,

   217     kInvalidSessionDescription        = 5,

   218     kIncompatibleSessionDescription   = 6,

   219     kIncompatibleConstraints          = 7,

   220     kIncompatibleMediaStreamTrack     = 8,

   221     kInternalError                    = 9

   222   };

   224   NS_DECL_THREADSAFE_ISUPPORTS

   226 #ifdef MOZILLA_INTERNAL_API

   227   virtual JSObject* WrapObject(JSContext* cx);

   228 #endif

   230   static already_AddRefed<PeerConnectionImpl>

   231       Constructor(const mozilla::dom::GlobalObject& aGlobal, ErrorResult& rv);

   232   static PeerConnectionImpl* CreatePeerConnection();

   233   static nsresult ConvertRTCConfiguration(const RTCConfiguration& aSrc,

   234                                           IceConfiguration *aDst);

   235   static already_AddRefed<DOMMediaStream> MakeMediaStream(nsPIDOMWindow* aWindow,

   236                                                           uint32_t aHint);

   238   nsresult CreateRemoteSourceStreamInfo(nsRefPtr<RemoteSourceStreamInfo>* aInfo);

   240   // Implementation of the only observer we need

   241   void onCallEvent(const OnCallEventArgs &args);

   243   // DataConnection observers

   244   void NotifyConnection();

   245   void NotifyClosedConnection();

   246   void NotifyDataChannel(already_AddRefed<mozilla::DataChannel> aChannel);

   248   // Get the media object

   249   const nsRefPtr<PeerConnectionMedia>& media() const {

   250     PC_AUTO_ENTER_API_CALL_NO_CHECK();

   251     return mMedia;

   252   }

   254   mozilla::LoadManager* load_manager()  {

   255     return mLoadManager;

   256   }

   258   // Handle system to allow weak references to be passed through C code

   259   virtual const std::string& GetHandle();

   261   // Name suitable for exposing to content

   262   virtual const std::string& GetName();

   264   // ICE events

   265   void IceConnectionStateChange(NrIceCtx* ctx,

   266                                 NrIceCtx::ConnectionState state);

   267   void IceGatheringStateChange(NrIceCtx* ctx,

   268                                NrIceCtx::GatheringState state);

   269   void IceStreamReady(NrIceMediaStream *aStream);

   271   static void ListenThread(void *aData);

   272   static void ConnectThread(void *aData);

   274   // Get the main thread

   275   nsCOMPtr<nsIThread> GetMainThread() {

   276     PC_AUTO_ENTER_API_CALL_NO_CHECK();

   277     return mThread;

   278   }

   280   // Get the STS thread

   281   nsCOMPtr<nsIEventTarget> GetSTSThread() {

   282     PC_AUTO_ENTER_API_CALL_NO_CHECK();

   283     return mSTSThread;

   284   }

   286   // Get the DTLS identity

   287   mozilla::RefPtr<DtlsIdentity> const GetIdentity() const;

   288   std::string GetFingerprint() const;

   289   std::string GetFingerprintAlgorithm() const;

   290   std::string GetFingerprintHexValue() const;

   292   // Create a fake media stream

   293   nsresult CreateFakeMediaStream(uint32_t hint, nsIDOMMediaStream** retval);

   295   nsPIDOMWindow* GetWindow() const {

   296     PC_AUTO_ENTER_API_CALL_NO_CHECK();

   297     return mWindow;

   298   }

   300   // Initialize PeerConnection from an IceConfiguration object (unit-tests)

   301   nsresult Initialize(PeerConnectionObserver& aObserver,

   302                       nsGlobalWindow* aWindow,

   303                       const IceConfiguration& aConfiguration,

   304                       nsIThread* aThread) {

   305     return Initialize(aObserver, aWindow, &aConfiguration, nullptr, aThread);

   306   }

   308   // Initialize PeerConnection from an RTCConfiguration object (JS entrypoint)

   309   void Initialize(PeerConnectionObserver& aObserver,

   310                   nsGlobalWindow& aWindow,

   311                   const RTCConfiguration& aConfiguration,

   312                   nsISupports* aThread,

   313                   ErrorResult &rv)

   314   {

   315     nsresult r = Initialize(aObserver, &aWindow, nullptr, &aConfiguration, aThread);

   316     if (NS_FAILED(r)) {

   317       rv.Throw(r);

   318     }

   319   }

   321   NS_IMETHODIMP_TO_ERRORRESULT(CreateOffer, ErrorResult &rv,

   322                                const MediaConstraintsInternal& aConstraints)

   323   {

   324     rv = CreateOffer(aConstraints);

   325   }

   327   NS_IMETHODIMP_TO_ERRORRESULT(CreateAnswer, ErrorResult &rv,

   328                                const MediaConstraintsInternal& aConstraints)

   329   {

   330     rv = CreateAnswer(aConstraints);

   331   }

   333   NS_IMETHODIMP CreateOffer(const MediaConstraintsExternal& aConstraints);

   334   NS_IMETHODIMP CreateAnswer(const MediaConstraintsExternal& aConstraints);

   336   NS_IMETHODIMP SetLocalDescription (int32_t aAction, const char* aSDP);

   338   void SetLocalDescription (int32_t aAction, const nsAString& aSDP, ErrorResult &rv)

   339   {

   340     rv = SetLocalDescription(aAction, NS_ConvertUTF16toUTF8(aSDP).get());

   341   }

   343   NS_IMETHODIMP SetRemoteDescription (int32_t aAction, const char* aSDP);

   345   void SetRemoteDescription (int32_t aAction, const nsAString& aSDP, ErrorResult &rv)

   346   {

   347     rv = SetRemoteDescription(aAction, NS_ConvertUTF16toUTF8(aSDP).get());

   348   }

   350   NS_IMETHODIMP_TO_ERRORRESULT(GetStats, ErrorResult &rv,

   351                                mozilla::dom::MediaStreamTrack *aSelector)

   352   {

   353     rv = GetStats(aSelector);

   354   }

   356   NS_IMETHODIMP AddIceCandidate(const char* aCandidate, const char* aMid,

   357                                 unsigned short aLevel);

   359   void AddIceCandidate(const nsAString& aCandidate, const nsAString& aMid,

   360                        unsigned short aLevel, ErrorResult &rv)

   361   {

   362     rv = AddIceCandidate(NS_ConvertUTF16toUTF8(aCandidate).get(),

   363                          NS_ConvertUTF16toUTF8(aMid).get(), aLevel);

   364   }

   366   NS_IMETHODIMP CloseStreams();

   368   void CloseStreams(ErrorResult &rv)

   369   {

   370     rv = CloseStreams();

   371   }

   373   NS_IMETHODIMP_TO_ERRORRESULT(AddStream, ErrorResult &rv,

   374                                DOMMediaStream& aMediaStream,

   375                                const MediaConstraintsInternal& aConstraints)

   376   {

   377     rv = AddStream(aMediaStream, aConstraints);

   378   }

   380   NS_IMETHODIMP AddStream(DOMMediaStream & aMediaStream,

   381                           const MediaConstraintsExternal& aConstraints);

   383   NS_IMETHODIMP_TO_ERRORRESULT(RemoveStream, ErrorResult &rv,

   384                                DOMMediaStream& aMediaStream)

   385   {

   386     rv = RemoveStream(aMediaStream);

   387   }

   389   NS_IMETHODIMP GetFingerprint(char** fingerprint);

   390   void GetFingerprint(nsAString& fingerprint)

   391   {

   392     char *tmp;

   393     GetFingerprint(&tmp);

   394     fingerprint.AssignASCII(tmp);

   395     delete[] tmp;

   396   }

   398   NS_IMETHODIMP GetLocalDescription(char** aSDP);

   400   void GetLocalDescription(nsAString& aSDP)

   401   {

   402     char *tmp;

   403     GetLocalDescription(&tmp);

   404     aSDP.AssignASCII(tmp);

   405     delete tmp;

   406   }

   408   NS_IMETHODIMP GetRemoteDescription(char** aSDP);

   410   void GetRemoteDescription(nsAString& aSDP)

   411   {

   412     char *tmp;

   413     GetRemoteDescription(&tmp);

   414     aSDP.AssignASCII(tmp);

   415     delete tmp;

   416   }

   418   NS_IMETHODIMP ReadyState(mozilla::dom::PCImplReadyState* aState);

   420   mozilla::dom::PCImplReadyState ReadyState()

   421   {

   422     mozilla::dom::PCImplReadyState state;

   423     ReadyState(&state);

   424     return state;

   425   }

   427   NS_IMETHODIMP SignalingState(mozilla::dom::PCImplSignalingState* aState);

   429   mozilla::dom::PCImplSignalingState SignalingState()

   430   {

   431     mozilla::dom::PCImplSignalingState state;

   432     SignalingState(&state);

   433     return state;

   434   }

   436   NS_IMETHODIMP SipccState(mozilla::dom::PCImplSipccState* aState);

   438   mozilla::dom::PCImplSipccState SipccState()

   439   {

   440     mozilla::dom::PCImplSipccState state;

   441     SipccState(&state);

   442     return state;

   443   }

   445   NS_IMETHODIMP IceConnectionState(

   446       mozilla::dom::PCImplIceConnectionState* aState);

   448   mozilla::dom::PCImplIceConnectionState IceConnectionState()

   449   {

   450     mozilla::dom::PCImplIceConnectionState state;

   451     IceConnectionState(&state);

   452     return state;

   453   }

   455   NS_IMETHODIMP IceGatheringState(

   456       mozilla::dom::PCImplIceGatheringState* aState);

   458   mozilla::dom::PCImplIceGatheringState IceGatheringState()

   459   {

   460     mozilla::dom::PCImplIceGatheringState state;

   461     IceGatheringState(&state);

   462     return state;

   463   }

   465   NS_IMETHODIMP Close();

   467   void Close(ErrorResult &rv)

   468   {

   469     rv = Close();

   470   }

   472   nsresult InitializeDataChannel(int track_id, uint16_t aLocalport,

   473                                  uint16_t aRemoteport, uint16_t aNumstreams);

   475   NS_IMETHODIMP_TO_ERRORRESULT(ConnectDataConnection, ErrorResult &rv,

   476                                uint16_t aLocalport,

   477                                uint16_t aRemoteport,

   478                                uint16_t aNumstreams)

   479   {

   480     rv = ConnectDataConnection(aLocalport, aRemoteport, aNumstreams);

   481   }

   483   NS_IMETHODIMP_TO_ERRORRESULT_RETREF(nsDOMDataChannel,

   484                                       CreateDataChannel, ErrorResult &rv,

   485                                       const nsAString& aLabel,

   486                                       const nsAString& aProtocol,

   487                                       uint16_t aType,

   488                                       bool outOfOrderAllowed,

   489                                       uint16_t aMaxTime,

   490                                       uint16_t aMaxNum,

   491                                       bool aExternalNegotiated,

   492                                       uint16_t aStream);

   494   NS_IMETHODIMP_TO_ERRORRESULT(GetLocalStreams, ErrorResult &rv,

   495                                nsTArray<nsRefPtr<DOMMediaStream > >& result)

   496   {

   497     rv = GetLocalStreams(result);

   498   }

   500   NS_IMETHODIMP_TO_ERRORRESULT(GetRemoteStreams, ErrorResult &rv,

   501                                nsTArray<nsRefPtr<DOMMediaStream > >& result)

   502   {

   503     rv = GetRemoteStreams(result);

   504   }

   506   // Called whenever something is unrecognized by the parser

   507   // May be called more than once and does not necessarily mean

   508   // that parsing was stopped, only that something was unrecognized.

   509   void OnSdpParseError(const char* errorMessage);

   511   // Called when OnLocal/RemoteDescriptionSuccess/Error

   512   // is called to start the list over.

   513   void ClearSdpParseErrorMessages();

   515   // Called to retreive the list of parsing errors.

   516   const std::vector<std::string> &GetSdpParseErrors();

   518   // Sets the RTC Signaling State

   519   void SetSignalingState_m(mozilla::dom::PCImplSignalingState aSignalingState);

   521   bool IsClosed() const;

   523   bool HasMedia() const;

   525 #ifdef MOZILLA_INTERNAL_API

   526   // initialize telemetry for when calls start

   527   void startCallTelem();

   529   nsresult BuildStatsQuery_m(

   530       mozilla::dom::MediaStreamTrack *aSelector,

   531       RTCStatsQuery *query);

   533   static nsresult ExecuteStatsQuery_s(RTCStatsQuery *query);

   534 #endif

   536 private:

   537   PeerConnectionImpl(const PeerConnectionImpl&rhs);

   538   PeerConnectionImpl& operator=(PeerConnectionImpl);

   539   NS_IMETHODIMP Initialize(PeerConnectionObserver& aObserver,

   540                            nsGlobalWindow* aWindow,

   541                            const IceConfiguration* aConfiguration,

   542                            const RTCConfiguration* aRTCConfiguration,

   543                            nsISupports* aThread);

   545   NS_IMETHODIMP EnsureDataConnection(uint16_t aNumstreams);

   547   nsresult CloseInt();

   548   void ChangeReadyState(mozilla::dom::PCImplReadyState aReadyState);

   549   nsresult CheckApiState(bool assert_ice_ready) const;

   550   void CheckThread() const {

   551     NS_ABORT_IF_FALSE(CheckThreadInt(), "Wrong thread");

   552   }

   553   bool CheckThreadInt() const {

   554 #ifdef MOZILLA_INTERNAL_API

   555     // Thread assertions are disabled in the C++ unit tests because those

   556     // make API calls off the main thread.

   557     // TODO(ekr@rtfm.com): Fix the unit tests so they don't do that.

   558     bool on;

   559     NS_ENSURE_SUCCESS(mThread->IsOnCurrentThread(&on), false);

   560     NS_ENSURE_TRUE(on, false);

   561 #endif

   562     return true;

   563   }

   565 #ifdef MOZILLA_INTERNAL_API

   566   void virtualDestroyNSSReference() MOZ_FINAL;

   567   void destructorSafeDestroyNSSReference();

   568   nsresult GetTimeSinceEpoch(DOMHighResTimeStamp *result);

   569 #endif

   571   // Shut down media - called on main thread only

   572   void ShutdownMedia();

   574   NS_IMETHOD FingerprintSplitHelper(

   575       std::string& fingerprint, size_t& spaceIdx) const;

   578 #ifdef MOZILLA_INTERNAL_API

   579   static void GetStatsForPCObserver_s(

   580       const std::string& pcHandle,

   581       nsAutoPtr<RTCStatsQuery> query);

   583   // Sends an RTCStatsReport to JS. Must run on main thread.

   584   static void DeliverStatsReportToPCObserver_m(

   585       const std::string& pcHandle,

   586       nsresult result,

   587       nsAutoPtr<RTCStatsQuery> query);

   588 #endif

   590   // When ICE completes, we record a bunch of statistics that outlive the

   591   // PeerConnection. This is just telemetry right now, but this can also

   592   // include things like dumping the RLogRingbuffer somewhere, saving away

   593   // an RTCStatsReport somewhere so it can be inspected after the call is over,

   594   // or other things.

   595   void RecordLongtermICEStatistics();

   597   // Timecard used to measure processing time. This should be the first class

   598   // attribute so that we accurately measure the time required to instantiate

   599   // any other attributes of this class.

   600   Timecard *mTimeCard;

   602   // The call

   603   mozilla::ScopedDeletePtr<Internal> mInternal;

   604   mozilla::dom::PCImplReadyState mReadyState;

   605   mozilla::dom::PCImplSignalingState mSignalingState;

   607   // ICE State

   608   mozilla::dom::PCImplIceConnectionState mIceConnectionState;

   609   mozilla::dom::PCImplIceGatheringState mIceGatheringState;

   611   nsCOMPtr<nsIThread> mThread;

   612   // TODO: Remove if we ever properly wire PeerConnection for cycle-collection.

   613   nsWeakPtr mPCObserver;

   615   nsCOMPtr<nsPIDOMWindow> mWindow;

   617   // The SDP sent in from JS - here for debugging.

   618   std::string mLocalRequestedSDP;

   619   std::string mRemoteRequestedSDP;

   620   // The SDP we are using.

   621   std::string mLocalSDP;

   622   std::string mRemoteSDP;

   624   // DTLS fingerprint

   625   std::string mFingerprint;

   626   std::string mRemoteFingerprint;

   628   // The DTLS identity

   629   mozilla::RefPtr<DtlsIdentity> mIdentity;

   631   // A handle to refer to this PC with

   632   std::string mHandle;

   634   // A name for this PC that we are willing to expose to content.

   635   std::string mName;

   637   // The target to run stuff on

   638   nsCOMPtr<nsIEventTarget> mSTSThread;

   640   // CPU Load adaptation stuff

   641   mozilla::LoadManager* mLoadManager;

   643 #ifdef MOZILLA_INTERNAL_API

   644   // DataConnection that's used to get all the DataChannels

   645 	nsRefPtr<mozilla::DataChannelConnection> mDataConnection;

   646 #endif

   648   nsRefPtr<PeerConnectionMedia> mMedia;

   650 #ifdef MOZILLA_INTERNAL_API

   651   // Start time of ICE, used for telemetry

   652   mozilla::TimeStamp mIceStartTime;

   653   // Start time of call used for Telemetry

   654   mozilla::TimeStamp mStartTime;

   655 #endif

   657   // Temporary: used to prevent multiple audio streams or multiple video streams

   658   // in a single PC. This is tied up in the IETF discussion around proper

   659   // representation of multiple streams in SDP, and strongly related to

   660   // Bug 840728.

   661   int mNumAudioStreams;

   662   int mNumVideoStreams;

   664   bool mHaveDataStream;

   666   // Holder for error messages from parsing SDP

   667   std::vector<std::string> mSDPParseErrorMessages;

   669   bool mTrickle;

   671 public:

   672   //these are temporary until the DataChannel Listen/Connect API is removed

   673   unsigned short listenPort;

   674   unsigned short connectPort;

   675   char *connectStr; // XXX ownership/free

   676 };

   678 // This is what is returned when you acquire on a handle

   679 class PeerConnectionWrapper

   680 {

   681  public:

   682   PeerConnectionWrapper(const std::string& handle);

   684   PeerConnectionImpl *impl() { return impl_; }

   686  private:

   687   nsRefPtr<PeerConnectionImpl> impl_;

   688 };

   690 }  // end sipcc namespace

   692 #undef NS_IMETHODIMP_TO_ERRORRESULT

   693 #undef NS_IMETHODIMP_TO_ERRORRESULT_RETREF

   694 #endif  // _PEER_CONNECTION_IMPL_H_

The Tor Browser / file revision

media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h@ac0c01689b40

media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h