Add m-esr52 at 52.6.0

1 files changed, 894 insertions, 0 deletions

diff --git a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
new file mode 100644
index 000000000..c29d08180
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
@@ -0,0 +1,894 @@
+/* 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 _PEER_CONNECTION_IMPL_H_
+#define _PEER_CONNECTION_IMPL_H_
+
+#include <deque>
+#include <string>
+#include <vector>
+#include <map>
+#include <cmath>
+
+#include "prlock.h"
+#include "mozilla/RefPtr.h"
+#include "nsWeakPtr.h"
+#include "nsAutoPtr.h"
+#include "nsIWeakReferenceUtils.h" // for the definition of nsWeakPtr
+#include "IPeerConnection.h"
+#include "sigslot.h"
+#include "nricectx.h"
+#include "nricemediastream.h"
+#include "nsComponentManagerUtils.h"
+#include "nsPIDOMWindow.h"
+#include "nsIUUIDGenerator.h"
+#include "nsIThread.h"
+
+#include "signaling/src/jsep/JsepSession.h"
+#include "signaling/src/jsep/JsepSessionImpl.h"
+#include "signaling/src/sdp/SdpMediaSection.h"
+
+#include "mozilla/ErrorResult.h"
+#include "mozilla/dom/PeerConnectionImplEnumsBinding.h"
+#include "PrincipalChangeObserver.h"
+#include "StreamTracks.h"
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "mozilla/TimeStamp.h"
+#include "mozilla/net/DataChannel.h"
+#include "VideoUtils.h"
+#include "VideoSegment.h"
+#include "mozilla/dom/RTCStatsReportBinding.h"
+#include "nsIPrincipal.h"
+#include "mozilla/PeerIdentity.h"
+#endif
+
+namespace test {
+#ifdef USE_FAKE_PCOBSERVER
+class AFakePCObserver;
+#endif
+}
+
+#ifdef USE_FAKE_MEDIA_STREAMS
+class Fake_DOMMediaStream;
+class Fake_MediaStreamTrack;
+#endif
+
+class nsGlobalWindow;
+class nsDOMDataChannel;
+
+namespace mozilla {
+class DataChannel;
+class DtlsIdentity;
+class NrIceCtx;
+class NrIceMediaStream;
+class NrIceStunServer;
+class NrIceTurnServer;
+class MediaPipeline;
+
+#ifdef USE_FAKE_MEDIA_STREAMS
+typedef Fake_DOMMediaStream DOMMediaStream;
+#else
+class DOMMediaStream;
+#endif
+
+namespace dom {
+class RTCCertificate;
+struct RTCConfiguration;
+class RTCDTMFSender;
+struct RTCIceServer;
+struct RTCOfferOptions;
+struct RTCRtpParameters;
+class RTCRtpSender;
+#ifdef USE_FAKE_MEDIA_STREAMS
+typedef Fake_MediaStreamTrack MediaStreamTrack;
+#else
+class MediaStreamTrack;
+#endif
+
+#ifdef USE_FAKE_PCOBSERVER
+typedef test::AFakePCObserver PeerConnectionObserver;
+typedef const char *PCObserverString;
+#else
+class PeerConnectionObserver;
+typedef NS_ConvertUTF8toUTF16 PCObserverString;
+#endif
+}
+}
+
+#if defined(__cplusplus) && __cplusplus >= 201103L
+typedef struct Timecard Timecard;
+#else
+#include "timecard.h"
+#endif
+
+// To preserve blame, convert nsresult to ErrorResult with wrappers. These macros
+// help declare wrappers w/function being wrapped when there are no differences.
+
+#define NS_IMETHODIMP_TO_ERRORRESULT(func, rv, ...) \
+NS_IMETHODIMP func(__VA_ARGS__);                    \
+void func (__VA_ARGS__, rv)
+
+#define NS_IMETHODIMP_TO_ERRORRESULT_RETREF(resulttype, func, rv, ...) \
+NS_IMETHODIMP func(__VA_ARGS__, resulttype **result);                  \
+already_AddRefed<resulttype> func (__VA_ARGS__, rv)
+
+struct MediaStreamTable;
+
+namespace mozilla {
+
+using mozilla::dom::PeerConnectionObserver;
+using mozilla::dom::RTCConfiguration;
+using mozilla::dom::RTCIceServer;
+using mozilla::dom::RTCOfferOptions;
+using mozilla::DOMMediaStream;
+using mozilla::NrIceCtx;
+using mozilla::NrIceMediaStream;
+using mozilla::DtlsIdentity;
+using mozilla::ErrorResult;
+using mozilla::NrIceStunServer;
+using mozilla::NrIceTurnServer;
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+using mozilla::PeerIdentity;
+#endif
+
+class PeerConnectionWrapper;
+class PeerConnectionMedia;
+class RemoteSourceStreamInfo;
+
+// Uuid Generator
+class PCUuidGenerator : public mozilla::JsepUuidGenerator {
+ public:
+  virtual bool Generate(std::string* idp) override;
+
+ private:
+  nsCOMPtr<nsIUUIDGenerator> mGenerator;
+};
+
+class PeerConnectionConfiguration
+{
+public:
+  PeerConnectionConfiguration()
+  : mBundlePolicy(kBundleBalanced),
+    mIceTransportPolicy(NrIceCtx::ICE_POLICY_ALL) {}
+
+  bool addStunServer(const std::string& addr, uint16_t port,
+                     const char* transport)
+  {
+    UniquePtr<NrIceStunServer> server(NrIceStunServer::Create(addr, port, transport));
+    if (!server) {
+      return false;
+    }
+    addStunServer(*server);
+    return true;
+  }
+  bool addTurnServer(const std::string& addr, uint16_t port,
+                     const std::string& username,
+                     const std::string& pwd,
+                     const char* transport)
+  {
+    // TODO(ekr@rtfm.com): Need support for SASLprep for
+    // username and password. Bug # ???
+    std::vector<unsigned char> password(pwd.begin(), pwd.end());
+
+    UniquePtr<NrIceTurnServer> server(NrIceTurnServer::Create(addr, port, username, password,
+							      transport));
+    if (!server) {
+      return false;
+    }
+    addTurnServer(*server);
+    return true;
+  }
+  void addStunServer(const NrIceStunServer& server) { mStunServers.push_back (server); }
+  void addTurnServer(const NrIceTurnServer& server) { mTurnServers.push_back (server); }
+  const std::vector<NrIceStunServer>& getStunServers() const { return mStunServers; }
+  const std::vector<NrIceTurnServer>& getTurnServers() const { return mTurnServers; }
+  void setBundlePolicy(JsepBundlePolicy policy) { mBundlePolicy = policy;}
+  JsepBundlePolicy getBundlePolicy() const { return mBundlePolicy; }
+  void setIceTransportPolicy(NrIceCtx::Policy policy) { mIceTransportPolicy = policy;}
+  NrIceCtx::Policy getIceTransportPolicy() const { return mIceTransportPolicy; }
+
+#ifndef MOZILLA_EXTERNAL_LINKAGE
+  nsresult Init(const RTCConfiguration& aSrc);
+  nsresult AddIceServer(const RTCIceServer& aServer);
+#endif
+
+private:
+  std::vector<NrIceStunServer> mStunServers;
+  std::vector<NrIceTurnServer> mTurnServers;
+  JsepBundlePolicy mBundlePolicy;
+  NrIceCtx::Policy mIceTransportPolicy;
+};
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+// Not an inner class so we can forward declare.
+class RTCStatsQuery {
+  public:
+    explicit RTCStatsQuery(bool internalStats);
+    ~RTCStatsQuery();
+
+    nsAutoPtr<mozilla::dom::RTCStatsReportInternal> report;
+    std::string error;
+    // A timestamp to help with telemetry.
+    mozilla::TimeStamp iceStartTime;
+    // Just for convenience, maybe integrate into the report later
+    bool failed;
+
+  private:
+    friend class PeerConnectionImpl;
+    std::string pcName;
+    bool internalStats;
+    nsTArray<RefPtr<mozilla::MediaPipeline>> pipelines;
+    RefPtr<NrIceCtx> iceCtx;
+    bool grabAllLevels;
+    DOMHighResTimeStamp now;
+};
+#endif // MOZILLA_INTERNAL_API
+
+// Enter an API call and check that the state is OK,
+// the PC isn't closed, etc.
+#define PC_AUTO_ENTER_API_CALL(assert_ice_ready) \
+    do { \
+      /* do/while prevents res from conflicting with locals */    \
+      nsresult res = CheckApiState(assert_ice_ready);             \
+      if (NS_FAILED(res)) return res; \
+    } while(0)
+#define PC_AUTO_ENTER_API_CALL_VOID_RETURN(assert_ice_ready) \
+    do { \
+      /* do/while prevents res from conflicting with locals */    \
+      nsresult res = CheckApiState(assert_ice_ready);             \
+      if (NS_FAILED(res)) return; \
+    } while(0)
+#define PC_AUTO_ENTER_API_CALL_NO_CHECK() CheckThread()
+
+class PeerConnectionImpl final : public nsISupports,
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+                                 public mozilla::DataChannelConnection::DataConnectionListener,
+                                 public dom::PrincipalChangeObserver<dom::MediaStreamTrack>,
+#endif
+                                 public sigslot::has_slots<>
+{
+  struct Internal; // Avoid exposing c includes to bindings
+
+public:
+  explicit PeerConnectionImpl(const mozilla::dom::GlobalObject* aGlobal = nullptr);
+
+  enum Error {
+    kNoError                          = 0,
+    kInvalidCandidate                 = 2,
+    kInvalidMediastreamTrack          = 3,
+    kInvalidState                     = 4,
+    kInvalidSessionDescription        = 5,
+    kIncompatibleSessionDescription   = 6,
+    kIncompatibleMediaStreamTrack     = 8,
+    kInternalError                    = 9
+  };
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  bool WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
+#endif
+
+  static already_AddRefed<PeerConnectionImpl>
+      Constructor(const mozilla::dom::GlobalObject& aGlobal, ErrorResult& rv);
+  static PeerConnectionImpl* CreatePeerConnection();
+  already_AddRefed<DOMMediaStream> MakeMediaStream();
+
+  nsresult CreateRemoteSourceStreamInfo(RefPtr<RemoteSourceStreamInfo>* aInfo,
+                                        const std::string& aId);
+
+  // DataConnection observers
+  void NotifyDataChannel(already_AddRefed<mozilla::DataChannel> aChannel)
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+    // PeerConnectionImpl only inherits from mozilla::DataChannelConnection
+    // inside libxul.
+    override
+#endif
+    ;
+
+  // Get the media object
+  const RefPtr<PeerConnectionMedia>& media() const {
+    PC_AUTO_ENTER_API_CALL_NO_CHECK();
+    return mMedia;
+  }
+
+  // Configure the ability to use localhost.
+  void SetAllowIceLoopback(bool val) { mAllowIceLoopback = val; }
+  bool GetAllowIceLoopback() const { return mAllowIceLoopback; }
+
+  // Configure the ability to use IPV6 link-local addresses.
+  void SetAllowIceLinkLocal(bool val) { mAllowIceLinkLocal = val; }
+  bool GetAllowIceLinkLocal() const { return mAllowIceLinkLocal; }
+
+  // Handle system to allow weak references to be passed through C code
+  virtual const std::string& GetHandle();
+
+  // Name suitable for exposing to content
+  virtual const std::string& GetName();
+
+  // ICE events
+  void IceConnectionStateChange(NrIceCtx* ctx,
+                                NrIceCtx::ConnectionState state);
+  void IceGatheringStateChange(NrIceCtx* ctx,
+                               NrIceCtx::GatheringState state);
+  void UpdateDefaultCandidate(const std::string& defaultAddr,
+                              uint16_t defaultPort,
+                              const std::string& defaultRtcpAddr,
+                              uint16_t defaultRtcpPort,
+                              uint16_t level);
+  void EndOfLocalCandidates(uint16_t level);
+  void IceStreamReady(NrIceMediaStream *aStream);
+
+  static void ListenThread(void *aData);
+  static void ConnectThread(void *aData);
+
+  // Get the main thread
+  nsCOMPtr<nsIThread> GetMainThread() {
+    PC_AUTO_ENTER_API_CALL_NO_CHECK();
+    return mThread;
+  }
+
+  // Get the STS thread
+  nsIEventTarget* GetSTSThread() {
+    PC_AUTO_ENTER_API_CALL_NO_CHECK();
+    return mSTSThread;
+  }
+
+  nsPIDOMWindowInner* GetWindow() const {
+    PC_AUTO_ENTER_API_CALL_NO_CHECK();
+    return mWindow;
+  }
+
+  // Initialize PeerConnection from a PeerConnectionConfiguration object
+  // (used directly by unit-tests, and indirectly by the JS entry point)
+  // This is necessary because RTCConfiguration can't be used by unit-tests
+  nsresult Initialize(PeerConnectionObserver& aObserver,
+                      nsGlobalWindow* aWindow,
+                      const PeerConnectionConfiguration& aConfiguration,
+                      nsISupports* aThread);
+
+#ifndef MOZILLA_EXTERNAL_LINKAGE
+  // Initialize PeerConnection from an RTCConfiguration object (JS entrypoint)
+  void Initialize(PeerConnectionObserver& aObserver,
+                  nsGlobalWindow& aWindow,
+                  const RTCConfiguration& aConfiguration,
+                  nsISupports* aThread,
+                  ErrorResult &rv);
+#endif
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  void SetCertificate(mozilla::dom::RTCCertificate& aCertificate);
+  const RefPtr<mozilla::dom::RTCCertificate>& Certificate() const;
+#endif
+  // This is a hack to support external linkage.
+  RefPtr<DtlsIdentity> Identity() const;
+
+  NS_IMETHODIMP_TO_ERRORRESULT(CreateOffer, ErrorResult &rv,
+                               const RTCOfferOptions& aOptions)
+  {
+    rv = CreateOffer(aOptions);
+  }
+
+  NS_IMETHODIMP CreateAnswer();
+  void CreateAnswer(ErrorResult &rv)
+  {
+    rv = CreateAnswer();
+  }
+
+  NS_IMETHODIMP CreateOffer(
+      const mozilla::JsepOfferOptions& aConstraints);
+
+  NS_IMETHODIMP SetLocalDescription (int32_t aAction, const char* aSDP);
+
+  void SetLocalDescription (int32_t aAction, const nsAString& aSDP, ErrorResult &rv)
+  {
+    rv = SetLocalDescription(aAction, NS_ConvertUTF16toUTF8(aSDP).get());
+  }
+
+  nsresult CreateNewRemoteTracks(RefPtr<PeerConnectionObserver>& aPco);
+
+  void RemoveOldRemoteTracks(RefPtr<PeerConnectionObserver>& aPco);
+
+  NS_IMETHODIMP SetRemoteDescription (int32_t aAction, const char* aSDP);
+
+  void SetRemoteDescription (int32_t aAction, const nsAString& aSDP, ErrorResult &rv)
+  {
+    rv = SetRemoteDescription(aAction, NS_ConvertUTF16toUTF8(aSDP).get());
+  }
+
+  NS_IMETHODIMP_TO_ERRORRESULT(GetStats, ErrorResult &rv,
+                               mozilla::dom::MediaStreamTrack *aSelector)
+  {
+    rv = GetStats(aSelector);
+  }
+
+  NS_IMETHODIMP AddIceCandidate(const char* aCandidate, const char* aMid,
+                                unsigned short aLevel);
+
+  void AddIceCandidate(const nsAString& aCandidate, const nsAString& aMid,
+                       unsigned short aLevel, ErrorResult &rv)
+  {
+    rv = AddIceCandidate(NS_ConvertUTF16toUTF8(aCandidate).get(),
+                         NS_ConvertUTF16toUTF8(aMid).get(), aLevel);
+  }
+
+  NS_IMETHODIMP CloseStreams();
+
+  void CloseStreams(ErrorResult &rv)
+  {
+    rv = CloseStreams();
+  }
+
+  NS_IMETHODIMP_TO_ERRORRESULT(AddTrack, ErrorResult &rv,
+      mozilla::dom::MediaStreamTrack& aTrack,
+      const mozilla::dom::Sequence<mozilla::OwningNonNull<DOMMediaStream>>& aStreams)
+  {
+    rv = AddTrack(aTrack, aStreams);
+  }
+
+  NS_IMETHODIMP_TO_ERRORRESULT(RemoveTrack, ErrorResult &rv,
+                               mozilla::dom::MediaStreamTrack& aTrack)
+  {
+    rv = RemoveTrack(aTrack);
+  }
+
+  nsresult
+  AddTrack(mozilla::dom::MediaStreamTrack& aTrack, DOMMediaStream& aStream);
+
+  NS_IMETHODIMP_TO_ERRORRESULT(InsertDTMF, ErrorResult &rv,
+                               dom::RTCRtpSender& sender,
+                               const nsAString& tones,
+                               uint32_t duration, uint32_t interToneGap) {
+    rv = InsertDTMF(sender, tones, duration, interToneGap);
+  }
+
+  NS_IMETHODIMP_TO_ERRORRESULT(GetDTMFToneBuffer, ErrorResult &rv,
+                               dom::RTCRtpSender& sender,
+                               nsAString& outToneBuffer) {
+    rv = GetDTMFToneBuffer(sender, outToneBuffer);
+  }
+
+  NS_IMETHODIMP_TO_ERRORRESULT(ReplaceTrack, ErrorResult &rv,
+                               mozilla::dom::MediaStreamTrack& aThisTrack,
+                               mozilla::dom::MediaStreamTrack& aWithTrack)
+  {
+    rv = ReplaceTrack(aThisTrack, aWithTrack);
+  }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  NS_IMETHODIMP_TO_ERRORRESULT(SetParameters, ErrorResult &rv,
+                               dom::MediaStreamTrack& aTrack,
+                               const dom::RTCRtpParameters& aParameters)
+  {
+    rv = SetParameters(aTrack, aParameters);
+  }
+
+  NS_IMETHODIMP_TO_ERRORRESULT(GetParameters, ErrorResult &rv,
+                               dom::MediaStreamTrack& aTrack,
+                               dom::RTCRtpParameters& aOutParameters)
+  {
+    rv = GetParameters(aTrack, aOutParameters);
+  }
+#endif
+
+  nsresult
+  SetParameters(dom::MediaStreamTrack& aTrack,
+                const std::vector<JsepTrack::JsConstraints>& aConstraints);
+
+  nsresult
+  GetParameters(dom::MediaStreamTrack& aTrack,
+                std::vector<JsepTrack::JsConstraints>* aOutConstraints);
+
+  NS_IMETHODIMP_TO_ERRORRESULT(SelectSsrc, ErrorResult &rv,
+                               dom::MediaStreamTrack& aRecvTrack,
+                               unsigned short aSsrcIndex)
+  {
+    rv = SelectSsrc(aRecvTrack, aSsrcIndex);
+  }
+
+  nsresult GetPeerIdentity(nsAString& peerIdentity)
+  {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+    if (mPeerIdentity) {
+      peerIdentity = mPeerIdentity->ToString();
+      return NS_OK;
+    }
+#endif
+
+    peerIdentity.SetIsVoid(true);
+    return NS_OK;
+  }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  const PeerIdentity* GetPeerIdentity() const { return mPeerIdentity; }
+  nsresult SetPeerIdentity(const nsAString& peerIdentity);
+
+  const std::string& GetIdAsAscii() const
+  {
+    return mName;
+  }
+
+  nsresult GetId(nsAString& id)
+  {
+    id = NS_ConvertASCIItoUTF16(mName.c_str());
+    return NS_OK;
+  }
+
+  nsresult SetId(const nsAString& id)
+  {
+    mName = NS_ConvertUTF16toUTF8(id).get();
+    return NS_OK;
+  }
+#endif
+
+  // this method checks to see if we've made a promise to protect media.
+  bool PrivacyRequested() const { return mPrivacyRequested; }
+
+  NS_IMETHODIMP GetFingerprint(char** fingerprint);
+  void GetFingerprint(nsAString& fingerprint)
+  {
+    char *tmp;
+    GetFingerprint(&tmp);
+    fingerprint.AssignASCII(tmp);
+    delete[] tmp;
+  }
+
+  NS_IMETHODIMP GetLocalDescription(char** aSDP);
+
+  void GetLocalDescription(nsAString& aSDP)
+  {
+    char *tmp;
+    GetLocalDescription(&tmp);
+    aSDP.AssignASCII(tmp);
+    delete[] tmp;
+  }
+
+  NS_IMETHODIMP GetRemoteDescription(char** aSDP);
+
+  void GetRemoteDescription(nsAString& aSDP)
+  {
+    char *tmp;
+    GetRemoteDescription(&tmp);
+    aSDP.AssignASCII(tmp);
+    delete[] tmp;
+  }
+
+  NS_IMETHODIMP SignalingState(mozilla::dom::PCImplSignalingState* aState);
+
+  mozilla::dom::PCImplSignalingState SignalingState()
+  {
+    mozilla::dom::PCImplSignalingState state;
+    SignalingState(&state);
+    return state;
+  }
+
+  NS_IMETHODIMP IceConnectionState(
+      mozilla::dom::PCImplIceConnectionState* aState);
+
+  mozilla::dom::PCImplIceConnectionState IceConnectionState()
+  {
+    mozilla::dom::PCImplIceConnectionState state;
+    IceConnectionState(&state);
+    return state;
+  }
+
+  NS_IMETHODIMP IceGatheringState(
+      mozilla::dom::PCImplIceGatheringState* aState);
+
+  mozilla::dom::PCImplIceGatheringState IceGatheringState()
+  {
+    mozilla::dom::PCImplIceGatheringState state;
+    IceGatheringState(&state);
+    return state;
+  }
+
+  NS_IMETHODIMP Close();
+
+  void Close(ErrorResult &rv)
+  {
+    rv = Close();
+  }
+
+  bool PluginCrash(uint32_t aPluginID,
+                   const nsAString& aPluginName);
+
+  void RecordEndOfCallTelemetry() const;
+
+  nsresult InitializeDataChannel();
+
+  NS_IMETHODIMP_TO_ERRORRESULT_RETREF(nsDOMDataChannel,
+                                      CreateDataChannel, ErrorResult &rv,
+                                      const nsAString& aLabel,
+                                      const nsAString& aProtocol,
+                                      uint16_t aType,
+                                      bool outOfOrderAllowed,
+                                      uint16_t aMaxTime,
+                                      uint16_t aMaxNum,
+                                      bool aExternalNegotiated,
+                                      uint16_t aStream);
+
+  NS_IMETHODIMP_TO_ERRORRESULT(GetLocalStreams, ErrorResult &rv,
+                               nsTArray<RefPtr<DOMMediaStream > >& result)
+  {
+    rv = GetLocalStreams(result);
+  }
+
+  NS_IMETHODIMP_TO_ERRORRESULT(GetRemoteStreams, ErrorResult &rv,
+                               nsTArray<RefPtr<DOMMediaStream > >& result)
+  {
+    rv = GetRemoteStreams(result);
+  }
+
+  // Called whenever something is unrecognized by the parser
+  // May be called more than once and does not necessarily mean
+  // that parsing was stopped, only that something was unrecognized.
+  void OnSdpParseError(const char* errorMessage);
+
+  // Called when OnLocal/RemoteDescriptionSuccess/Error
+  // is called to start the list over.
+  void ClearSdpParseErrorMessages();
+
+  // Called to retreive the list of parsing errors.
+  const std::vector<std::string> &GetSdpParseErrors();
+
+  // Sets the RTC Signaling State
+  void SetSignalingState_m(mozilla::dom::PCImplSignalingState aSignalingState,
+                           bool rollback = false);
+
+  // Updates the RTC signaling state based on the JsepSession state
+  void UpdateSignalingState(bool rollback = false);
+
+  bool IsClosed() const;
+  // called when DTLS connects; we only need this once
+  nsresult SetDtlsConnected(bool aPrivacyRequested);
+
+  bool HasMedia() const;
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  // initialize telemetry for when calls start
+  void startCallTelem();
+
+  nsresult BuildStatsQuery_m(
+      mozilla::dom::MediaStreamTrack *aSelector,
+      RTCStatsQuery *query);
+
+  static nsresult ExecuteStatsQuery_s(RTCStatsQuery *query);
+
+  // for monitoring changes in track ownership
+  // PeerConnectionMedia can't do it because it doesn't know about principals
+  virtual void PrincipalChanged(dom::MediaStreamTrack* aTrack) override;
+
+#endif
+
+  static std::string GetStreamId(const DOMMediaStream& aStream);
+  static std::string GetTrackId(const dom::MediaStreamTrack& track);
+
+  void OnMediaError(const std::string& aError);
+
+private:
+  virtual ~PeerConnectionImpl();
+  PeerConnectionImpl(const PeerConnectionImpl&rhs);
+  PeerConnectionImpl& operator=(PeerConnectionImpl);
+  nsresult CalculateFingerprint(const std::string& algorithm,
+                                std::vector<uint8_t>* fingerprint) const;
+  nsresult ConfigureJsepSessionCodecs();
+
+  NS_IMETHODIMP EnsureDataConnection(uint16_t aNumstreams);
+
+  nsresult CloseInt();
+  nsresult CheckApiState(bool assert_ice_ready) const;
+  void CheckThread() const {
+    MOZ_ASSERT(CheckThreadInt(), "Wrong thread");
+  }
+  bool CheckThreadInt() const {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+    // Thread assertions are disabled in the C++ unit tests because those
+    // make API calls off the main thread.
+    // This affects the standalone version of WebRTC since it is also used
+    // for an alternate build of the unit tests.
+    // TODO(ekr@rtfm.com): Fix the unit tests so they don't do that.
+    bool on;
+    NS_ENSURE_SUCCESS(mThread->IsOnCurrentThread(&on), false);
+    NS_ENSURE_TRUE(on, false);
+#endif
+    return true;
+  }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  nsresult GetTimeSinceEpoch(DOMHighResTimeStamp *result);
+#endif
+
+  // Shut down media - called on main thread only
+  void ShutdownMedia();
+
+  void CandidateReady(const std::string& candidate, uint16_t level);
+  void SendLocalIceCandidateToContent(uint16_t level,
+                                      const std::string& mid,
+                                      const std::string& candidate);
+
+  nsresult GetDatachannelParameters(
+      const mozilla::JsepApplicationCodecDescription** codec,
+      uint16_t* level) const;
+
+  static void DeferredAddTrackToJsepSession(const std::string& pcHandle,
+                                            SdpMediaSection::MediaType type,
+                                            const std::string& streamId,
+                                            const std::string& trackId);
+
+  nsresult AddTrackToJsepSession(SdpMediaSection::MediaType type,
+                                 const std::string& streamId,
+                                 const std::string& trackId);
+
+  nsresult SetupIceRestart();
+  nsresult RollbackIceRestart();
+  void FinalizeIceRestart();
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  static void GetStatsForPCObserver_s(
+      const std::string& pcHandle,
+      nsAutoPtr<RTCStatsQuery> query);
+
+  // Sends an RTCStatsReport to JS. Must run on main thread.
+  static void DeliverStatsReportToPCObserver_m(
+      const std::string& pcHandle,
+      nsresult result,
+      nsAutoPtr<RTCStatsQuery> query);
+#endif
+
+  // When ICE completes, we record a bunch of statistics that outlive the
+  // PeerConnection. This is just telemetry right now, but this can also
+  // include things like dumping the RLogConnector somewhere, saving away
+  // an RTCStatsReport somewhere so it can be inspected after the call is over,
+  // or other things.
+  void RecordLongtermICEStatistics();
+
+  void OnNegotiationNeeded();
+  static void MaybeFireNegotiationNeeded_static(const std::string& pcHandle);
+  void MaybeFireNegotiationNeeded();
+
+  // Timecard used to measure processing time. This should be the first class
+  // attribute so that we accurately measure the time required to instantiate
+  // any other attributes of this class.
+  Timecard *mTimeCard;
+
+  mozilla::dom::PCImplSignalingState mSignalingState;
+
+  // ICE State
+  mozilla::dom::PCImplIceConnectionState mIceConnectionState;
+  mozilla::dom::PCImplIceGatheringState mIceGatheringState;
+
+  // DTLS
+  // this is true if we have been connected ever, see SetDtlsConnected
+  bool mDtlsConnected;
+
+  nsCOMPtr<nsIThread> mThread;
+  // TODO: Remove if we ever properly wire PeerConnection for cycle-collection.
+  nsWeakPtr mPCObserver;
+
+  nsCOMPtr<nsPIDOMWindowInner> mWindow;
+
+  // The SDP sent in from JS - here for debugging.
+  std::string mLocalRequestedSDP;
+  std::string mRemoteRequestedSDP;
+
+  // DTLS fingerprint
+  std::string mFingerprint;
+  std::string mRemoteFingerprint;
+
+  // identity-related fields
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  // The entity on the other end of the peer-to-peer connection;
+  // void if they are not yet identified, and no identity setting has been set
+  RefPtr<PeerIdentity> mPeerIdentity;
+  // The certificate we are using.
+  RefPtr<mozilla::dom::RTCCertificate> mCertificate;
+#else
+  RefPtr<DtlsIdentity> mIdentity;
+#endif
+  // Whether an app should be prevented from accessing media produced by the PC
+  // If this is true, then media will not be sent until mPeerIdentity matches
+  // local streams PeerIdentity; and remote streams are protected from content
+  //
+  // This can be false if mPeerIdentity is set, in the case where identity is
+  // provided, but the media is not protected from the app on either side
+  bool mPrivacyRequested;
+
+  // A handle to refer to this PC with
+  std::string mHandle;
+
+  // A name for this PC that we are willing to expose to content.
+  std::string mName;
+
+  // The target to run stuff on
+  nsCOMPtr<nsIEventTarget> mSTSThread;
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  // DataConnection that's used to get all the DataChannels
+  RefPtr<mozilla::DataChannelConnection> mDataConnection;
+#endif
+
+  bool mAllowIceLoopback;
+  bool mAllowIceLinkLocal;
+  RefPtr<PeerConnectionMedia> mMedia;
+
+  // The JSEP negotiation session.
+  mozilla::UniquePtr<PCUuidGenerator> mUuidGen;
+  mozilla::UniquePtr<mozilla::JsepSession> mJsepSession;
+  std::string mPreviousIceUfrag; // used during rollback of ice restart
+  std::string mPreviousIcePwd; // used during rollback of ice restart
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  // Start time of ICE, used for telemetry
+  mozilla::TimeStamp mIceStartTime;
+  // Start time of call used for Telemetry
+  mozilla::TimeStamp mStartTime;
+#endif
+
+  // Temporary: used to prevent multiple audio streams or multiple video streams
+  // in a single PC. This is tied up in the IETF discussion around proper
+  // representation of multiple streams in SDP, and strongly related to
+  // Bug 840728.
+  int mNumAudioStreams;
+  int mNumVideoStreams;
+  bool mHaveConfiguredCodecs;
+
+  bool mHaveDataStream;
+
+  unsigned int mAddCandidateErrorCount;
+
+  bool mTrickle;
+
+  bool mNegotiationNeeded;
+
+  bool mPrivateWindow;
+
+  // storage for Telemetry data
+  uint16_t mMaxReceiving[SdpMediaSection::kMediaTypes];
+  uint16_t mMaxSending[SdpMediaSection::kMediaTypes];
+
+  // DTMF
+  class DTMFState : public nsITimerCallback {
+      virtual ~DTMFState();
+    public:
+      DTMFState();
+
+      NS_DECL_NSITIMERCALLBACK
+      NS_DECL_THREADSAFE_ISUPPORTS
+
+      PeerConnectionImpl* mPeerConnectionImpl;
+      nsCOMPtr<nsITimer> mSendTimer;
+      nsString mTrackId;
+      nsString mTones;
+      size_t mLevel;
+      uint32_t mDuration;
+      uint32_t mInterToneGap;
+  };
+
+  nsTArray<RefPtr<DTMFState>> mDTMFStates;
+
+public:
+  //these are temporary until the DataChannel Listen/Connect API is removed
+  unsigned short listenPort;
+  unsigned short connectPort;
+  char *connectStr; // XXX ownership/free
+};
+
+// This is what is returned when you acquire on a handle
+class PeerConnectionWrapper
+{
+ public:
+  explicit PeerConnectionWrapper(const std::string& handle);
+
+  PeerConnectionImpl *impl() { return impl_; }
+
+ private:
+  RefPtr<PeerConnectionImpl> impl_;
+};
+
+}  // end mozilla namespace
+
+#undef NS_IMETHODIMP_TO_ERRORRESULT
+#undef NS_IMETHODIMP_TO_ERRORRESULT_RETREF
+#endif  // _PEER_CONNECTION_IMPL_H_