--- a/media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
+++ b/media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
@@ -571,17 +571,16 @@ WebrtcVideoConduit::ConfigureSendMediaCo
     // overrides the calculations above
     if (mSendingWidth) { // cleared if we need a reconfig
       SelectBitrates(video_stream.width, video_stream.height,
                      simulcastEncoding.constraints.maxBr,
                      mLastFramerateTenths, video_stream);
     }
 
     video_stream.max_qp = kQpMax;
-    video_stream.SetRid(simulcastEncoding.rid);
     simulcast_config.jsScaleDownBy = simulcastEncoding.constraints.scaleDownBy;
     simulcast_config.jsMaxBitrate = simulcastEncoding.constraints.maxBr; // bps
 
     if (codecConfig->mName == "H264") {
       if (codecConfig->mEncodingConstraints.maxMbps > 0) {
         // Not supported yet!
         CSFLogError(logTag, "%s H.264 max_mbps not supported yet", __FUNCTION__);
       }

--- a/media/webrtc/signaling/src/media-conduit/VideoConduit.h
+++ b/media/webrtc/signaling/src/media-conduit/VideoConduit.h
@@ -469,19 +469,16 @@ private:
   bool mVideoLatencyTestEnable;
   uint64_t mVideoLatencyAvg;
   int mMinBitrate;
   int mStartBitrate;
   int mPrefMaxBitrate;
   int mNegotiatedMaxBitrate;
   int mMinBitrateEstimate;
 
-  bool mRtpStreamIdEnabled;
-  uint8_t mRtpStreamIdExtId;
-
   static const unsigned int sAlphaNum = 7;
   static const unsigned int sAlphaDen = 8;
   static const unsigned int sRoundingPadding = 1024;
 
   RefPtr<WebrtcAudioConduit> mSyncedTo;
 
   nsAutoPtr<LoadManager> mLoadManager;
   webrtc::VideoCodecMode mCodecMode;

--- a/media/webrtc/trunk/webrtc/config.h
+++ b/media/webrtc/trunk/webrtc/config.h
@@ -82,28 +82,16 @@ struct VideoStream {
   int max_framerate;
 
   int min_bitrate_bps;
   int target_bitrate_bps;
   int max_bitrate_bps;
 
   int max_qp;
 
-  char rid[kRIDSize+1];
-
-  const std::string Rid() const {
-    return std::string(rid);
-  }
-
-  void SetRid(const std::string & aRid) {
-    static_assert(sizeof(rid) > kRIDSize,
-      "mRid must be large enought to hold a RID + null termination");
-    strncpy(&rid[0], aRid.c_str(), std::min((size_t)kRIDSize, aRid.length()));
-    rid[kRIDSize] = 0;
-  }
   // Bitrate thresholds for enabling additional temporal layers. Since these are
   // thresholds in between layers, we have one additional layer. One threshold
   // gives two temporal layers, one below the threshold and one above, two give
   // three, and so on.
   // The VideoEncoder may redistribute bitrates over the temporal layers so a
   // bitrate threshold of 100k and an estimate of 105k does not imply that we
   // get 100k in one temporal layer and 5k in the other, just that the bitrate
   // in the first temporal layer should not exceed 100k.

--- a/media/webrtc/trunk/webrtc/video/vie_channel.cc
+++ b/media/webrtc/trunk/webrtc/video/vie_channel.cc
@@ -39,18 +39,16 @@
 namespace webrtc {
 
 const int kMaxDecodeWaitTimeMs = 50;
 static const int kMaxTargetDelayMs = 10000;
 const int kMinSendSidePacketHistorySize = 600;
 const int kMaxPacketAgeToNack = 450;
 const int kMaxNackListSize = 250;
 
-const int kInvalidRtpExtensionId = 0; //MOZ addition for RtpSenderId (RID)
-
 // Helper class receiving statistics callbacks.
 class ChannelStatsObserver : public CallStatsObserver {
  public:
   explicit ChannelStatsObserver(ViEChannel* owner) : owner_(owner) {}
   virtual ~ChannelStatsObserver() {}
 
   // Implements StatsObserver.
   virtual void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
@@ -117,17 +115,16 @@ ViEChannel::ViEChannel(uint32_t number_o
       nack_history_size_sender_(kMinSendSidePacketHistorySize),
       max_nack_reordering_threshold_(kMaxPacketAgeToNack),
       pre_render_callback_(NULL),
       report_block_stats_sender_(new ReportBlockStats()),
       time_of_first_rtt_ms_(-1),
       rtt_sum_ms_(0),
       last_rtt_ms_(0),
       num_rtts_(0),
-			rid_extension_id_(kInvalidRtpExtensionId),
       rtp_rtcp_modules_(
           CreateRtpRtcpModules(!sender,
                                vie_receiver_.GetReceiveStatistics(),
                                transport,
                                intra_frame_observer_,
                                bandwidth_observer_.get(),
                                transport_feedback_observer_,
                                rtt_stats_,
@@ -658,27 +655,25 @@ int ViEChannel::SetReceiveTransportSeque
   return vie_receiver_.SetReceiveTransportSequenceNumber(enable, id) ? 0 : -1;
 }
 
 int ViEChannel::SetSendRtpStreamId(bool enable, int id) { //}, const char *rid)
   CriticalSectionScoped cs(crit_.get());
   int error = 0;
   if (enable) {
     // Enable the extension, but disable possible old id to avoid errors.
-    rid_extension_id_ = id;
     for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
       rtp_rtcp->DeregisterSendRtpHeaderExtension(
         kRtpExtensionRtpStreamId);
       error = rtp_rtcp->RegisterSendRtpHeaderExtension(
         kRtpExtensionRtpStreamId, id);
     }
     // NOTE: simulcast streams must be set via the SetSendCodec() API
   } else {
     // Disable the extension.
-    rid_extension_id_ = kInvalidRtpExtensionId;
     for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     	rtp_rtcp->DeregisterSendRtpHeaderExtension(
         kRtpExtensionRtpStreamId);
     }
   }
   return error;
 }
 

--- a/media/webrtc/trunk/webrtc/video/vie_channel.h
+++ b/media/webrtc/trunk/webrtc/video/vie_channel.h
@@ -458,17 +458,16 @@ int32_t GetRemoteRTCPSenderInfo(RTCPSend
   I420FrameCallback* pre_render_callback_ GUARDED_BY(crit_);
 
   const rtc::scoped_ptr<ReportBlockStats> report_block_stats_sender_;
 
   int64_t time_of_first_rtt_ms_ GUARDED_BY(crit_);
   int64_t rtt_sum_ms_ GUARDED_BY(crit_);
   int64_t last_rtt_ms_ GUARDED_BY(crit_);
   size_t num_rtts_ GUARDED_BY(crit_);
-	int rid_extension_id_; // RtpStreamId (RID)
 
   // RtpRtcp modules, declared last as they use other members on construction.
   const std::vector<RtpRtcp*> rtp_rtcp_modules_;
   size_t num_active_rtp_rtcp_modules_ GUARDED_BY(crit_);
 };
 
 }  // namespace webrtc