Adds stats and audio levels for Safari. Enables the new getStats API for Firefox, that will get rid of the following warning:
'non-maplike pc.getStats access is deprecated, and will be removed in the near future! See http://w3c.github.io/webrtc-pc/#getstats-example for usage.'

This PR exposes the functionality that's already built-in the
TraceablePeerConnection that has it gather stats from the wrapped
PeerConnection.

This commit will append "-" + tpc.id to every local 'MSID', 'cname',
'label' and 'mslabel', before feeding the local SDP to the Jingle layer.
It will make stream IDs unique across TraceablePeerConnection instances
and prevent from conflicts in some corner cases.

For example this will fix a problem where if the client drops
the conference without leaving the XMPP MUC gracefully and will join
the conference again without recreating the local tracks it would lead
to the MSID conflict, because the stream is still advertised by
"the ghost" participant.

In order to include browser capabilities in RTCBrowserType I needed to
refactor RTCBrowserType.

In Rect Native it will stall the app as it's huge.

jitsi-meet has been changed to have tpc.js on info by default, so these
logs still won't show by default.

Calling JSON.stringify on a temasys object causes a stack overflow.
The result is that the JingleSessionPC's work queue never gets
cleared so future work, like video muting, will not get called.
Instead of passing in the candidate directly, manually do
what chrome's implementation of candidate.toJSON does.

Adds rtc.LOCAL_TRACK_SSRC_UPDATED event to be emitted when ssrc is updated for a local track.
Fixes adding rtc listeners for CREATE_ANSWER_FAILED, CREATE_OFFER_FAILED, SET_LOCAL_DESCRIPTION_FAILED, SET_REMOTE_DESCRIPTION_FAILED.

Error handling was added to ensure some munging helpers
were receiving RTCSessionDescriptions. Temasys is doing
something else and is passing its own object into
the mungers. So, let temasys do that.

IE11 errors when adding a temasys media stream object to
a Set. So instead use an Array.

Safari will fail to set its remote description if no
supported video codecs are found. This can happen with
config.p2p.disableH264 set to true, as browsers will strip
H264 from their offers. To get around this problem in a way
that can be removed once this is fixed on Safari's side,
add a function to inject H265 before setting the remote
description.

* ref(sdp): lower logs about missing local video to warning

* ref(sdp): earlier error handling for missing description and mlines

* ref(sdp): rename maybeMungeLocalSdp to be more specific

Firefox has deprecated modifying a description's sdp through
re-assignment. Safari (without temasys) does not allow it.
As such, wherever the sdp has to be modified instead create
a new description with the modified sdp.

- Add a new browser check so adapter shim usage can be gated.
- Get track resolution for stats from the track itself to account
  for browser resolution fallback logic. Do this only if
  we can be sure adapter has shimmed it in.
- Create a new getUserMediaFlow, with RTC being the orchestration
  for various RTCUtils calls.
- Remove connection quality stat "resolution" which was being
  emitted but not used but listeners.

This is performed by stripping all traces of H.264 from the local SDP before
passing it to `setLocalDescription`.

ESLint 4.8.0 discovers a lot of error related to formatting. While I
tried to fix as many of them as possible, a portion of them actually go
against our coding style. In such a case, I've disabled the indent rule
which effectively leaves it as it was before ESLint 4.8.0.

For p2p, we have to take preferh264 into account when setting the local description, since
that prefer is what will be received by the far side.  if we only do it on the remote description,
like before this change, we'll never actually end up preferring h264.

The 'setMutedInProgress' flag is unreliable and it can lead to weird
situations when mute operation is in progress, but the removal from
JingleSessionPC is waiting on the queue. In such case LocalSdpMunger
will fake SDP even if the track is in the PeerConnection which may
confuse some parts of the SDP transformation chain.

For example RtxModifier will not attempt to inject Rtx group description
if it sees that the SSRC are already there. But it can happen that even
though the SSRCs are there they do not contain valid track ID, because
the track has changed.

The LocalSdpMunger is supposed to fake the SDP only when the video
MediaStream is not in the PeerConnection. So this commit implements just
that: a way to tell if JitsiLocalTrack's stream is currently in
the PeerConnection (added through TraceablePeerConnection).

* add support for signaling simulcast for unified plan

1) munge the incoming offer to advertise support for receiving simulcast in unified plan
2) add 3 simulcast encodings via rtp sender
3) inject an ssrc-group line, even when using rids for simulcast (jicofo will rely on this)

* add rid information to the session-accept jingle

* address lenny's feedback

* make firefox simulcast configurable

* fix missing comma

* ref(JSPC): simplify SSRC owner in P2P

There's no need for any extra extensions for SSRCs owner signalling in
P2P, because it's always the remote peer who owns them.

This also fixes a problem where no SSRC owner was added for 'source-add'
in P2P (for JVB conference Jicofo adds that).

* fix(TPC): always advertise 'sendrecv'

Our media direction is only ever updated on the remote side with
the initial offer (or answer). Because of that we want to advertise
'sendrecv' even if we start with no video (or audio) track.

It is OK to adjust this direction in the localDescription getter,
because it's adjusted again in the setter to the correct value based on
local tracks, so the SDP transformation chain still works fine.

When the lastN is set to 0 the P2P session will notify the remote peer
to stop sending video.

If the app depends on tracking current tracks state using
"track added/removed" events, the tracks will be leaking if
JitsiConference.leave() method is used. That's because peerconnections
are closed and removed from RTC module and then from onMemberLeft those
events will not be fired, because tracks will be gone with
the peerconnections.

Also removes error message log, because it no longer makes sense if
the tracks can be removed early by "stop P2P" logic without actually
removing them from the TPC. Then when the TPC is closed it will try to
emit the events again. But this time it will not match any tracks in
the JitsiParticipant, because it has been removed already.

It's the same EventEmitter anyway, but looks a bit more consistent.

* feat: multiple, simultaneous RTP stats

Makes it possible to have remote RTP stats running for more than one
peerconnection at a time.

* feat(stats): report RTT all the time

Will report JVB RTT (and end to end) while in P2P mode and vice versa.

* fix(JitsiConferenceEvents): remove CONNECTION_STATS

CONNECTION_STATS event is no longer emitted.

* fix(AvgRTPStatsReported): users with no video

Do not include FPS == 0 in average remote FPS calculation. Report NaN
for local FPS when video muted or no video device. NaN will be reported
for avg remote FPS if no video is received.

* fix(AvgRTPStatsReported): reset total packet loss

* feat(AvgRTPStatsReported): report 'screen' FPS

Will report average FPS for screen videos separately from camera videos,
but only if available (camera video reports NaN FPS when not available).

* fix(AvgRTPStatsReported): end2endRTT

Needs to report JSON with value.

* feat(AVG RTP stats): separate audio and video bitrate

Will report average audio and video bitrates separately.

* doc(JitsiConference): try to improve comment

* fix(AvgRTPStatsReporter): remove confusing reset

There's no a clear reason for doing reset there.

* ref(AvgRTPStatsReporter): rename var

* ref: store SSRCs as a number

Converts all the places where SSRCs where stored as string to use
numbers.

* doc(RTPStatsCollector): getNonNegativeStat

Fixes invalid description about returning NaN.

* ref(JitsiConf...EventManager): simplify for..of

* ref(JitsiRemoteTrack): throw TypeError

Will throw a TypeError when 'ssrc' is not a number.

* fix(RTPStatsCollector): invalid reference

* doc(RTPStatsCollector): getNonNegativeStat private

* ref(RTPStatsCollector): simplify for..of

* fix(SSRCs): check for negative value

Will not accept negative SSRCs, since those are supposed to be unsigned.

There was 'supportsSimulcast' method already, so removing
'isSimulcastSupported'.

Move 'isSimulcastSupported' check from sdp-simulcast to the client.

Avoids having to do browser checks twice.

Fixes: #423

Ensures that the simulcast ssrc-group appears after any other
ssrc-groups in the SDP so that simulcast is properly activated.

Webpack 2 defines module.exports as a read-only property in ES6 modules.

* ref(CallStats): cleanup constructor

Changes CallStats constructor to not take the whole JingleSessionPC as
it only needs an alias and the TraceablePeerConnection instance.

Describes the arguments in JSDoc.

* ref(CallStats): rename var

Everything is callstats c'mon...

* ref(CallStats): remove _checkInitialize

The _checkInitialize was trying to workaround CallStats lib issue
without really checking for any specific type of error on whether or not
it makes sense to retry.

Also it depended on some internal fields of 'callStatsBackend' and was
binding 'initCallback' to the backend instead of CallStats instance
which made no sense (it means it's very likely this functionality was
broken anyway).

It would be hard to fix it in a clean way, because CallStats instance
fields would have to be stored in static variables in order to make
the initCallback work (called from '_checkInitialize').

We also need to have more than one CallStats instance running at the
same time, because of the P2P which makes things even more complex.

* fix(CallStats): do not catch 'sendApplicationLog'

Wrapping 'sendApplicationLog' in 'tryCatch' will result in an endless
loop, because it will be logged on the logger.error which then tries
to send the logs immediately again.

* ref(CallStats): do not use call on static

There's nothing more confusing that seeing 'this' in a static method.
Wow maybe these methods are not really static !?

* ref(stats): fix var name

* feat(stats): report P2P to CallStats

Will create new CallStats fabric for the P2P peerconnection in order to
log peer to peer connections.

Refactoring was required in the statistics and CallStats module to be
able to have more than one CallStats instance. Because each CallStats
fabric reports one peer connection now each CallStats will correspond to
one TraceablePeerConnection. CallStats instances are now stored in a Map
mapped by the TraceablePeerConnection.id field.

In order to be able to execute some global/static CallStats reporting
methods all Statistics instances also need to be stored in a static
field.

CallStats API backend(new callstats()) will be initialized only once for
the values provided in the first call to initializeBackend. It is not
possible to have more that one CallStats backend running at the same
time (at the time of this writing). If we would have a routine for
disposing global "Statistics" module we could try to cleanup static
reference and allow to initialize it with new values (but no such use
case yet).

* ref(CallStats): move initCallback

Since there is no alphabetic order preserved in this file anyway at
least place it closer to it's usage.

* ref(CallStats): remove tryCatch

Temporarily removes tryCatch to make the ES6 conversion easier.

* ref(CallStats): convert to ES6

* style(CallStats): fix indentation

* fix(statistics): use import for CallStats

* ref(CallStats): convert static methods

Some of the methods should not be static, because it only make sense
to call it when there is CallStats instance available.

* ref(CallStats): rename var

* doc(CallStats): remove misplaced comment

* chore(CallStats): remove invalid eslint comment

* fix(CallStats): undefined CallStats namespace

If no CallStats ID namespace option is provided the conference will be
reported without it.

* style(stats|CallStats): remove extra lines

* fix(CallStats): do not log error from tryCatch

GlobalOnErrorHandler calls logger.error anyway.

* fix(CallStats): cleanup tryCatch

If I understand correctly our initial intention with doing tryCatch was
to avoid crashing the whole app in case the CallStats backend would
crash. With this commit the tryCatch is done by wrapping original
backend instance methods or using explicit try catch block where
the method is called only from one place or a value needs to be returned
in case of a crash.

* ref(CallStats): make backend a static var

* fix(CallStats): invalid eslint comments

* ref(CallStats): use for..of

* ref(CallStats): fixes around REST args

* ref(CallStats): rename var

* ref(CallStats): reorder static methods

Also renamed some callbacks

* doc(CallStats): adds some docs

* ref(CallStats): make methods not static

Both 'sendDominantSpeakerEvent' and 'sendScreenSharingEvent' methods are
not really static as they require instance to be called.

* fix(CallStats): invalid key

* fix(CallStats): reduce amount of debug logs

* feat(p2p|CallStats): log hold/resume

Will put CallStats fabric for the JVB connection "on hold" while in p2p
mode.

* doc(CallStats): add FIXME

* doc(JitsiConference,CallStats): typos and renaming

Renames '_applyLocalSSRCMap' and improves description to remove
confusion with SSRC manipulation.

* ref(p2p): use SDP 'inactive' for JVB

This commit gets rid of detach/attach logic and
replaces it with SDP media direction modification.
Now after switching to P2P instead of detaching local
tracks from the JVB peerconnection only the media direction
will be changed to 'inactive'. This will suspend media
transfer on the JVB connection.

It's meant to mitigate Chrome issue where it would randomly
choose to stop sending audio stream, after we modify it's
local SSRC.

* ref(SdpConsistency): cleanup 'recvonly'

Checking on 'recvonly' is no longer reliable way for detecting
whether video media is recvonly, because it can be set to
'inactive' at any point.

Added a check to make sure that the recvonly SSRC is not generated
more than once from '_createOfferOrAnswer'.

* log TPC instance

Logs the TraceablePeerConnection from LocalSdpMunger and
SdpConsistency as part of log messages. Given that there can be
2 TPCs at the same time it was hard to tell for which connection
a log message was printed.

* fix(SdpConsistency): depend on 'recvonly' direction

When createAnswer/createOffer returns SDP it will contain 'recvonly'
direction to reflect current media stream state even though we set
it to 'sendrecv' previously. Using 'hasAnyTracksOfType(VIDEO)' can
not be used to reliably detect 'recvonly' direction when doing video
mute, because muted video track is still in the TPC's map.

* doc(LocalSdpMunger): update description

LocalSdpMunger is currently used only for muted local video tracks.

* fix(P2P): enable P2P on Firefox

After 'detach/attach' is gone it seems that P2P works fine with Firefox.

* ref(TPC): simplify expression

* ref(SdpConsistency): do not pass whole TPC

There's no need to pass whole TPC instance if the only thing needed is
a logging prefix.

Temasys plugin does not allow to bind PeerConnection's
methods.

* ref(RTC): store remote tracks in peer TPC

In order to implement P2P <-> JVB connection switching we need to
be able to associate remote tracks with the TraceablePeerConnections.

* feat(ChatRoom): multiple presence handlers

Add support for more than 1 presence handler per tag name.

* feat(JitsiLocalTrack): update stored MSID

* ref(stats): add peer connection arg to BYTE_SENT_STATS

Required to store local SSRCs in TraceablePeerConnection.

* ref: change local SSRCs strategy

* fix: generate recvonly SSRC if 0 video tracks

Video SSRC has to be generated for the recvonly stream if there are no
video tracks in the PeerConnection.

* feat: add "attach" and "detach" methods

* feat(jitsi tracks): improve logging

Adds toString methods and improve log messages around local and remote
tracks.

* ref(modify SSRCs): optimisations + fixes

- adds _doRenegotiate to JingleSessionPC that wraps some of
  the duplicated logic
- fixes problems with attach/detach
- renames methods to reflect what that they really do (operate on
  JitsiTrack rather than streams)

* ref(JingleSessionPC): remove duplication

Extracts common code for the 'modificationQueue' execution

* ref(VideoMuteSdpHack): rename, add docs, fix minor

Renames, adds docs and moves 'modified' flag and media direction
modification.

* ref(TPC): add 'isSimulcastOn'

* ref(MungeLocalSdp): move to RTC module

* ref: move "ufrag" events to the RTC module

* ref(JitsiConference): use promises for mute

* feat(XMPPEvents): add CONNECTION_ESTABLISHED

* feat: add peer to peer

* fix(P2P): deal with everyone's a moderator + fixes

* feat(P2P): implement "backToP2PDelay"

* fix(TPC): crash on FF accessing LD/RD

Firefox return null/undefined for localDescription/remoteDescription
objects if they have not been set yet, while Chrome does return empty
object instead. This commit makes the behaviour consistent by making
sure that at least empty object is returned for all browsers.

* fix(TPC): replace isFirefox with feature

* fix(JSPC): fix renegotiate crash on FF

FF does not allow to call 'createAnswer' in 'have-local-offer' state

* fix(JSPC): fix addIceCandidate crash on FF

* doc(JitsiConference): fix outdated comment

To be squashed with "ref(ChatRoom): remove unnecessary JingleSessionPC dependency"

* style(JitsiConference): rename arg to "jingleSession"

* feat(stats): add 'p2p' to 'transport'

The new p2p field will inform whether the transport comes from the peer
to peer type of connection or not.

* doc(TPC): describe local maps

* fix(P2P): multiplex between JVB and P2P ICE status

Will make sure that when in P2P mode the conference will be updated
with the ICE state coming from P2P and when in the JVB mode will get
the JVB one.

* doc(TPC): fixes docs and adds FIXME

* ref: use 'doesVideoMuteByStreamRemove'

* feat(P2P): stop P2P when ICE enters FAILED

The conference will switch back to the JVB connection when P2P
connection breaks (ICE enters failed state).

* feat(P2P): "connectivity-error" for ICE failed

Will use "connectivity-error" reason element name when ending P2P
session due to ICE failure.

* feat(xmpp): make P2P Stun servers configurable

STUN servers used in the P2P connection can be configured through
"p2pStunServers" option.

* ref(JitsiConference): use 'getActivePeerConnection'

* fix(P2P): re-create 'dtmfManager'

* ref(P2P): deal with ICE "completed" state

* ref(RTC): rename "owner" to "ownerEndpointId"

* fix(MungeLocalSdp): fix directions

* ref(ParticipantConnectionStatus): use for..of and () =>

* remove double 'l'

* ref: fix ESLint errors

* fix(MungeLocalSdp): adopt to new SdpTransformerUtil

* ref(MungeLocalSdp): use for .. of

* ref(SdpTransformUtil): remove "forEachSSRCAttr"

* fix(SDPDiffer): fix invalid "arrayEquals" call

* doc(MungeLocalSdp): add fixme

* fix(P2PEnabledConference): JVB tracks not added

* ref(JitsiConference): doc + rename mute methods

* ref(JitsiConference): adjust log level

* fix(JitsiConference): remove invalid eslint comments

Some mistake during rebase merge

* doc(JitsiConference): add FIXME

* ref(JitsiConferenceEventManager): stick to "tpc"

* ref(JitsiLocalTrack): use Set for "peerConnections"

* ref(JitsiLocalTrack): simplify expression

* ref(MungeLocalSdp): style + doc fixes

* ref: rename MungeLocalSdp to LocalSdpMunger

* ref(ParticipantConn..Status): rename method

* ref(SignalingLayerImpl): use Map and =>

* fix(strophe.jingle.js): minor style fixes + rename

* doc(XMPPEvents): typo

* doc(P2PEnabledConference): typo and style

* ref(P2PEnabledConference): rename methods

* ref(P2PEnabledConference): do not use "window"

* fix(P2PEnabledConference): cleanup deferred task

* ref(TPC): make options the last arg

* ref(TPC): use Map

* ref(TPC): syntax and other fixes...

* doc(ChatRoom): remove comment

* ref: remove P2PEnabledConference

* fix: remove JSUtil.js

* ref(LocalSdpMunger): re-use 'RtxModifier'

Reuses RtxModifier for injecting local RTX SSRCs as part of
the LocalSdpMunger logic.

* doc(LocalSdpMunger): remove confusing FIXME

* fix(TPC): setLocalDescription for FF

* fix(LocalSdpMunger): crash on react-native

* fix(JingleSessionPC): no events when ended

The instance once terminated should not emit connection state events.

* fix(P2P): do not start P2P on react-native

* fix: log meaningful error

Prior to this change you would see something like:
JitsiConference <error>: null

* fix(JingleSessionPC): no IQs once ended

* fix(JingleSessionPC): Jingle error logging

* fix: arguments order

* fix: make audio SSRC consistent

Audio SSRC needs to stay consistent between detach and attach operations
in order to avoid source-remove/source-add.

* fix(P2P): disable P2P on FF

There are problems with going back from P2P to JVB in FireFox. Other
participants will not see FF video. Looks like something related to
detach/attach.

* fix(JitsiConference): attach local tracks

Local tracks should be attached back to the JVB connection only
if the P2P was established.

* ref(JitsiConference): PR review fixes

ref(JitsiConference): else if

ref(JitsiConference): use getter

doc(JitsiConference): add comment

style(JitsiConference): remove extra line

log(JitsiConference): misleading msg

ref(JitsiConference): rename method

* ref(RTC): del _iteratePeerConnections

* ref: move getUfrag to SDPUtil

* fix(LocalSdpMunger): docs and if check

* fix(TPC): docs and typo

* ref(JingleSessionPC): PR review fixes

ref(JingleSessionPC): rename 'candidates'

ref(JitsiConference): remove extra check

ref(JitsiConference): rename isP2PEstablished

ref(JitsiConference): rename field (typo)

* doc(JitsiConferenceEventManager): typo

* ref(JitsiLocalTrack): rename var

* ref(JitsiConference): PR review fixes

ref(JitsiConference): rename var

doc(JitsiConference): add comment

doc(JitsiConference): add comment

doc(JitsiConference): fix comment

ref(JitsiConference): rename listener

ref(JitsiConference): rename var

* doc(RTC): remove duplicated arg description

doc(RTC): fill docs

* doc(SignalingLayerImpl): remove fixed FIXME

* ref(strophe.jingle.js): remove comment and break line

* style(TPC): formatting

doc(TPC): add FIXME

ref(TPC): remove unused code

doc(TPC): add docs

* doc(JingleSessionPC): mark "send" methods private

style(JingleSessionPC): extra lines

A browser can only support one of the "plans" so use an if-else.