--- a/media/webrtc/signaling/src/jsep/JsepSessionImpl.cpp
+++ b/media/webrtc/signaling/src/jsep/JsepSessionImpl.cpp
@@ -2388,16 +2388,18 @@ void
 JsepSessionImpl::SetupDefaultRtpExtensions()
 {
   AddAudioRtpExtension(webrtc::RtpExtension::kAudioLevelUri,
                        SdpDirectionAttribute::Direction::kSendonly);
   AddVideoRtpExtension(webrtc::RtpExtension::kAbsSendTimeUri,
                        SdpDirectionAttribute::Direction::kSendrecv);
   AddVideoRtpExtension(webrtc::RtpExtension::kTimestampOffsetUri,
                        SdpDirectionAttribute::Direction::kSendrecv);
+  AddVideoRtpExtension(webrtc::RtpExtension::kMIdUri,
+                       SdpDirectionAttribute::Direction::kSendrecv);
 }
 
 void
 JsepSessionImpl::SetState(JsepSignalingState state)
 {
   if (state == mState)
     return;
 

--- a/media/webrtc/signaling/src/media-conduit/AudioConduit.cpp
+++ b/media/webrtc/signaling/src/media-conduit/AudioConduit.cpp
@@ -159,16 +159,22 @@ bool WebrtcAudioConduit::GetRemoteSSRC(u
 bool WebrtcAudioConduit::SetLocalCNAME(const char* cname)
 {
   char temp[256];
   strncpy(temp, cname, sizeof(temp) - 1);
   temp[sizeof(temp) - 1] = 0;
   return !mPtrRTP->SetRTCP_CNAME(mChannel, temp);
 }
 
+bool WebrtcAudioConduit::SetLocalMID(const std::string& mid)
+{
+  // !mjf! stubbed out for now
+  return false;
+}
+
 bool WebrtcAudioConduit::GetSendPacketTypeStats(
   webrtc::RtcpPacketTypeCounter* aPacketCounts)
 {
   if (!mEngineTransmitting) {
     return false;
   }
   return !mPtrVoERTP_RTCP->GetRTCPPacketTypeCounters(mChannel, *aPacketCounts);
 }

--- a/media/webrtc/signaling/src/media-conduit/AudioConduit.h
+++ b/media/webrtc/signaling/src/media-conduit/AudioConduit.h
@@ -199,16 +199,17 @@ public:
   bool SetLocalSSRCs(const std::vector<unsigned int>& aSSRCs) override;
   std::vector<unsigned int> GetLocalSSRCs() const override;
   bool SetRemoteSSRC(unsigned int ssrc) override
   {
     return false;
   }
   bool GetRemoteSSRC(unsigned int* ssrc) override;
   bool SetLocalCNAME(const char* cname) override;
+  bool SetLocalMID(const std::string& mid) override;
 
   bool GetSendPacketTypeStats(
       webrtc::RtcpPacketTypeCounter* aPacketCounts) override;
 
   bool GetRecvPacketTypeStats(
       webrtc::RtcpPacketTypeCounter* aPacketCounts) override;
 
   bool GetVideoEncoderStats(double* framerateMean,

--- a/media/webrtc/signaling/src/media-conduit/MediaConduitInterface.h
+++ b/media/webrtc/signaling/src/media-conduit/MediaConduitInterface.h
@@ -224,16 +224,18 @@ public:
    */
   virtual bool SetLocalSSRCs(const std::vector<unsigned int>& aSSRCs) = 0;
   virtual std::vector<unsigned int> GetLocalSSRCs() const = 0;
 
   virtual bool GetRemoteSSRC(unsigned int* ssrc) = 0;
   virtual bool SetRemoteSSRC(unsigned int ssrc) = 0;
   virtual bool SetLocalCNAME(const char* cname) = 0;
 
+  virtual bool SetLocalMID(const std::string& mid) = 0;
+
   /**
    * Functions returning stats needed by w3c stats model.
    */
 
   virtual bool
   GetSendPacketTypeStats(webrtc::RtcpPacketTypeCounter* aPacketCounts) = 0;
 
   virtual bool

--- a/media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
+++ b/media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
@@ -365,16 +365,22 @@ WebrtcVideoConduit::GetLocalSSRCs() cons
 
 bool
 WebrtcVideoConduit::SetLocalCNAME(const char* cname)
 {
   mSendStreamConfig.rtp.c_name = cname;
   return true;
 }
 
+bool WebrtcVideoConduit::SetLocalMID(const std::string& mid)
+{
+  mSendStreamConfig.rtp.mid = mid;
+  return true;
+}
+
 MediaConduitErrorCode
 WebrtcVideoConduit::ConfigureCodecMode(webrtc::VideoCodecMode mode)
 {
   CSFLogVerbose(logTag, "%s ", __FUNCTION__);
   if (mode == webrtc::VideoCodecMode::kRealtimeVideo ||
       mode == webrtc::VideoCodecMode::kScreensharing) {
     mCodecMode = mode;
     return kMediaConduitNoError;

--- a/media/webrtc/signaling/src/media-conduit/VideoConduit.h
+++ b/media/webrtc/signaling/src/media-conduit/VideoConduit.h
@@ -293,16 +293,17 @@ public:
   virtual MediaConduitErrorCode Init();
   virtual void Destroy();
 
   std::vector<unsigned int> GetLocalSSRCs() const override;
   bool SetLocalSSRCs(const std::vector<unsigned int> & ssrcs) override;
   bool GetRemoteSSRC(unsigned int* ssrc) override;
   bool SetRemoteSSRC(unsigned int ssrc) override;
   bool SetLocalCNAME(const char* cname) override;
+  bool SetLocalMID(const std::string& mid) override;
 
   bool GetSendPacketTypeStats(
       webrtc::RtcpPacketTypeCounter* aPacketCounts) override;
 
   bool GetRecvPacketTypeStats(
       webrtc::RtcpPacketTypeCounter* aPacketCounts) override;
 
   bool GetVideoEncoderStats(double* framerateMean,

--- a/media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.cpp
+++ b/media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.cpp
@@ -863,25 +863,27 @@ MediaPipelineFactory::GetOrCreateVideoCo
     }
 
     if (!conduit->SetLocalSSRCs(*ssrcs)) {
       MOZ_MTLOG(ML_ERROR, "SetLocalSSRC failed");
       return NS_ERROR_FAILURE;
     }
 
     conduit->SetLocalCNAME(aTrack.GetCNAME().c_str());
+    conduit->SetLocalMID(aTrackPair.mRtpTransport->mTransportId);
 
     rv = ConfigureVideoCodecMode(aTrack, *conduit);
     if (NS_FAILED(rv)) {
       return rv;
     }
 
     if (!extmaps.empty()) {
       conduit->SetLocalRTPExtensions(true, extmaps);
     }
+
     auto error = conduit->ConfigureSendMediaCodec(configs.values[0]);
     if (error) {
       MOZ_MTLOG(ML_ERROR, "ConfigureSendMediaCodec failed: " << error);
       return NS_ERROR_FAILURE;
     }
   }
 
   *aConduitp = conduit;

--- a/media/webrtc/trunk/webrtc/config.cc
+++ b/media/webrtc/trunk/webrtc/config.cc
@@ -93,17 +93,18 @@ bool RtpExtension::IsSupportedForAudio(c
 
 bool RtpExtension::IsSupportedForVideo(const std::string& uri) {
   return uri == webrtc::RtpExtension::kTimestampOffsetUri ||
          uri == webrtc::RtpExtension::kAbsSendTimeUri ||
          uri == webrtc::RtpExtension::kVideoRotationUri ||
          uri == webrtc::RtpExtension::kTransportSequenceNumberUri ||
          uri == webrtc::RtpExtension::kPlayoutDelayUri ||
          uri == webrtc::RtpExtension::kRtpStreamIdUri ||
-         uri == webrtc::RtpExtension::kRepairedRtpStreamIdUri;
+         uri == webrtc::RtpExtension::kRepairedRtpStreamIdUri ||
+         uri == webrtc::RtpExtension::kMIdUri;
 }
 
 VideoStream::VideoStream()
     : width(0),
       height(0),
       max_framerate(-1),
       min_bitrate_bps(-1),
       target_bitrate_bps(-1),

--- a/media/webrtc/trunk/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h
+++ b/media/webrtc/trunk/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h
@@ -173,16 +173,18 @@ class RtpRtcp : public Module {
   virtual RtpState GetRtpState() const = 0;
   virtual RtpState GetRtxState() const = 0;
 
   // Returns SSRC.
   virtual uint32_t SSRC() const = 0;
 
   // Set RID value for the RID header extension or RTCP SDES
   virtual int32_t SetRID(const char *rid) = 0;
+  // Set MID value for the MID header extension
+  virtual int32_t SetMID(const char *mid) = 0;
 
   // Sets SSRC, default is a random number.
   virtual void SetSSRC(uint32_t ssrc) = 0;
 
   // Sets CSRC.
   // |csrcs| - vector of CSRCs
   virtual void SetCsrcs(const std::vector<uint32_t>& csrcs) = 0;
 

--- a/media/webrtc/trunk/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
+++ b/media/webrtc/trunk/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
@@ -72,16 +72,17 @@ class MockRtpRtcp : public RtpRtcp {
   MOCK_METHOD1(SetSequenceNumber, void(uint16_t seq));
   MOCK_METHOD1(SetRtpState, void(const RtpState& rtp_state));
   MOCK_METHOD1(SetRtxState, void(const RtpState& rtp_state));
   MOCK_CONST_METHOD0(GetRtpState, RtpState());
   MOCK_CONST_METHOD0(GetRtxState, RtpState());
   MOCK_CONST_METHOD0(SSRC, uint32_t());
   MOCK_METHOD1(SetSSRC, void(uint32_t ssrc));
   MOCK_METHOD1(SetRID, int32_t(const char *rid));
+  MOCK_METHOD1(SetMID, int32_t(const char *mid));
   MOCK_CONST_METHOD1(CSRCs, int32_t(uint32_t csrcs[kRtpCsrcSize]));
   MOCK_METHOD1(SetCsrcs, void(const std::vector<uint32_t>& csrcs));
   MOCK_METHOD1(SetCSRCStatus, int32_t(bool include));
   MOCK_METHOD1(SetRtxSendStatus, void(int modes));
   MOCK_CONST_METHOD0(RtxSendStatus, int());
   MOCK_METHOD1(SetRtxSsrc, void(uint32_t));
   MOCK_METHOD2(SetRtxSendPayloadType, void(int, int));
   MOCK_CONST_METHOD0(FlexfecSsrc, rtc::Optional<uint32_t>());

--- a/media/webrtc/trunk/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/media/webrtc/trunk/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -328,16 +328,20 @@ void ModuleRtpRtcpImpl::SetCsrcs(const s
   rtp_sender_.SetCsrcs(csrcs);
 }
 
 int32_t ModuleRtpRtcpImpl::SetRID(const char *rid) {
   //XXX rtcp_sender_.SetRID(rid);
   return rtp_sender_.SetRID(rid);
 }
 
+int32_t ModuleRtpRtcpImpl::SetMID(const char *mid) {
+  return rtp_sender_.SetMId(mid);
+}
+
 // TODO(pbos): Handle media and RTX streams separately (separate RTCP
 // feedbacks).
 RTCPSender::FeedbackState ModuleRtpRtcpImpl::GetFeedbackState() {
   StreamDataCounters rtp_stats;
   StreamDataCounters rtx_stats;
   rtp_sender_.GetDataCounters(&rtp_stats, &rtx_stats);
 
   RTCPSender::FeedbackState state;

--- a/media/webrtc/trunk/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/media/webrtc/trunk/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@@ -84,16 +84,17 @@ class ModuleRtpRtcpImpl : public RtpRtcp
   uint32_t SSRC() const override;
 
   // Configure SSRC, default is a random number.
   void SetSSRC(uint32_t ssrc) override;
 
   void SetCsrcs(const std::vector<uint32_t>& csrcs) override;
 
   int32_t SetRID(const char *rid) override;
+  int32_t SetMID(const char *mid) override;
 
   RTCPSender::FeedbackState GetFeedbackState();
 
   void SetRtxSendStatus(int mode) override;
   int RtxSendStatus() const override;
 
   void SetRtxSsrc(uint32_t ssrc) override;
 

--- a/media/webrtc/trunk/webrtc/video/video_send_stream.cc
+++ b/media/webrtc/trunk/webrtc/video/video_send_stream.cc
@@ -820,16 +820,21 @@ VideoSendStreamImpl::VideoSendStreamImpl
   }
 
   remb_->AddRembSender(rtp_rtcp_modules_[0]);
   rtp_rtcp_modules_[0]->SetREMBStatus(true);
 
   ConfigureProtection();
   ConfigureSsrcs();
 
+  // Configure the mid for each of the rtp modules
+  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
+    rtp_rtcp->SetMID(config_->rtp.mid.c_str());
+  }
+
   // TODO(pbos): Should we set CNAME on all RTP modules?
   rtp_rtcp_modules_.front()->SetCNAME(config_->rtp.c_name.c_str());
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->RegisterRtcpStatisticsCallback(stats_proxy_);
     rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(stats_proxy_);
     rtp_rtcp->SetMaxRtpPacketSize(config_->rtp.max_packet_size);
     rtp_rtcp->RegisterVideoSendPayload(

--- a/media/webrtc/trunk/webrtc/video_send_stream.h
+++ b/media/webrtc/trunk/webrtc/video_send_stream.h
@@ -164,16 +164,17 @@ class VideoSendStream {
         // Payload type to use for the RTX stream.
         int payload_type = -1;
       } rtx;
 
       // RTCP CNAME, see RFC 3550.
       std::string c_name;
 
       std::vector<std::string> rids;
+      std::string mid;
     } rtp;
 
     // Transport for outgoing packets.
     Transport* send_transport = nullptr;
 
     // Called for each I420 frame before encoding the frame. Can be used for
     // effects, snapshots etc. 'nullptr' disables the callback.
     rtc::VideoSinkInterface<VideoFrame>* pre_encode_callback = nullptr;