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

modules/RTC/JitsiRemoteTrack.js

  * @param {RTC} rtc the RTC service instance.
  * @param {JitsiConference} conference the conference to which this track
  *        belongs to
- * @param {string} owner the endpoint ID of the track owner
+ * @param {string} ownerEndpointId the endpoint ID of the track owner
  * @param {MediaStream} stream WebRTC MediaStream, parent of the track
  * @param {MediaStreamTrack} track underlying WebRTC MediaStreamTrack for
  *        the new JitsiRemoteTrack
  * @param {boolean} muted the initial muted state
  * @constructor
  */
-function JitsiRemoteTrack(rtc, conference, owner, stream, track, mediaType, videoType,
-                          ssrc, muted) {
+function JitsiRemoteTrack(rtc, conference, ownerEndpointId, stream, track,
+                          mediaType, videoType, ssrc, muted) {
     JitsiTrack.call(
         this, conference, stream, track, function () {}, mediaType, videoType, ssrc);
     this.rtc = rtc;
-    this.owner = owner;
+    this.ownerEndpointId = ownerEndpointId;
     this.muted = muted;
     // we want to mark whether the track has been ever muted
     // to detect ttfm events for startmuted conferences, as it can significantly
  * endpoint id/MUC nickname in case of Jitsi-meet.
  */
 JitsiRemoteTrack.prototype.getParticipantId = function() {
-    return this.owner;
+    return this.ownerEndpointId;
 };
 
 /**

modules/RTC/RTC.js

      * Initializes a new JitsiRemoteTrack instance with the data provided by
      * the signalling layer and SDP.
      *
-     * @param {string} owner
+     * @param {string} ownerEndpointId
      * @param {MediaStream} stream
      * @param {MediaStreamTrack} track
      * @param {MediaType} mediaType
      * @param {string} ssrc
      * @param {boolean} muted
      */
-    _createRemoteTrack (owner,
+    _createRemoteTrack (ownerEndpointId,
                         stream, track, mediaType, videoType, ssrc, muted) {
         const remoteTrack
             = new JitsiRemoteTrack(
-                this, this.conference, owner, stream, track,
+                this, this.conference, ownerEndpointId, stream, track,
                 mediaType, videoType, ssrc, muted);
         const remoteTracks
-            = this.remoteTracks[owner] || (this.remoteTracks[owner] = {});
+            = this.remoteTracks[ownerEndpointId]
+                || (this.remoteTracks[ownerEndpointId] = {});
 
         if (remoteTracks[mediaType]) {
-            logger.error("Overwriting remote track!", owner, mediaType);
+            logger.error(
+                "Overwriting remote track!", ownerEndpointId, mediaType);
         }
         remoteTracks[mediaType] = remoteTrack;
 

modules/RTC/TraceablePeerConnection.js

     // FIXME the length of ssrcLines[0] not verified, but it will fail
     // with global error handler anyway
     let trackSsrc = ssrcLines[0].substring(7).split(' ')[0];
-    const owner = this.signallingLayer.getSSRCOwner(trackSsrc);
+    const ownerEndpointId = this.signallingLayer.getSSRCOwner(trackSsrc);
 
-    if (!owner) {
+    if (!ownerEndpointId) {
         GlobalOnErrorHandler.callErrorHandler(
             new Error(
                 "No SSRC owner known for: " + trackSsrc
         return;
     }
 
-    logger.log('associated ssrc', owner, trackSsrc);
+    logger.log('associated ssrc', ownerEndpointId, trackSsrc);
 
     const peerMediaInfo
-        = this.signallingLayer.getPeerMediaInfo(owner, mediaType);
+        = this.signallingLayer.getPeerMediaInfo(ownerEndpointId, mediaType);
 
     if (!peerMediaInfo) {
         GlobalOnErrorHandler.callErrorHandler(
-            new Error("No peer media info available for: " + owner));
+            new Error("No peer media info available for: " + ownerEndpointId));
         // Abort
         return;
     }
     const videoType = peerMediaInfo.videoType; // can be undefined
 
     this.rtc._createRemoteTrack(
-        owner, stream, track, mediaType, videoType, trackSsrc, muted);
+        ownerEndpointId, stream, track, mediaType, videoType, trackSsrc, muted);
 };
 
 /**