diff --git a/api/rtp_sender_interface.h b/api/rtp_sender_interface.h
index 8507731..e0a29a3 100644
--- a/api/rtp_sender_interface.h
+++ b/api/rtp_sender_interface.h
@@ -61,11 +61,6 @@
   // tracks.
   virtual std::vector<std::string> stream_ids() const = 0;
 
-  // Sets the IDs of the media streams associated with  this sender's track.
-  // These are signalled in the SDP so that the remote side can associate
-  // tracks.
-  virtual void SetStreamIDs(const std::vector<std::string>& stream_ids) {}
-
   // Returns the list of encoding parameters that will be applied when the SDP
   // local description is set. These initial encoding parameters can be set by
   // PeerConnection::AddTransceiver, and later updated with Get/SetParameters.
@@ -117,7 +112,6 @@
               rtc::scoped_refptr<FrameEncryptorInterface>)
 PROXY_CONSTMETHOD0(rtc::scoped_refptr<FrameEncryptorInterface>,
                    GetFrameEncryptor)
-PROXY_METHOD1(void, SetStreamIDs, const std::vector<std::string>&)
 END_PROXY_MAP()
 
 }  // namespace webrtc
diff --git a/pc/peer_connection.cc b/pc/peer_connection.cc
index 551b0ed..065247d 100644
--- a/pc/peer_connection.cc
+++ b/pc/peer_connection.cc
@@ -1373,7 +1373,7 @@
           RtpTransceiverDirection::kSendOnly);
     }
     transceiver->sender()->SetTrack(track);
-    transceiver->internal()->sender_internal()->SetStreamIDs(stream_ids);
+    transceiver->internal()->sender_internal()->set_stream_ids(stream_ids);
   } else {
     cricket::MediaType media_type =
         (track->kind() == MediaStreamTrackInterface::kAudioKind
@@ -1632,19 +1632,19 @@
                (track->kind() == MediaStreamTrackInterface::kAudioKind));
     sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
         signaling_thread(),
-        AudioRtpSender::Create(worker_thread(), id, stats_.get(), this));
+        AudioRtpSender::Create(worker_thread(), id, stats_.get()));
     NoteUsageEvent(UsageEvent::AUDIO_ADDED);
   } else {
     RTC_DCHECK_EQ(media_type, cricket::MEDIA_TYPE_VIDEO);
     RTC_DCHECK(!track ||
                (track->kind() == MediaStreamTrackInterface::kVideoKind));
     sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
-        signaling_thread(), VideoRtpSender::Create(worker_thread(), id, this));
+        signaling_thread(), VideoRtpSender::Create(worker_thread(), id));
     NoteUsageEvent(UsageEvent::VIDEO_ADDED);
   }
   bool set_track_succeeded = sender->SetTrack(track);
   RTC_DCHECK(set_track_succeeded);
-  sender->internal()->SetStreamIDs(stream_ids);
+  sender->internal()->set_stream_ids(stream_ids);
   sender->internal()->set_init_send_encodings(send_encodings);
   return sender;
 }
@@ -1722,14 +1722,14 @@
   rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> new_sender;
   if (kind == MediaStreamTrackInterface::kAudioKind) {
     auto audio_sender = AudioRtpSender::Create(
-        worker_thread(), rtc::CreateRandomUuid(), stats_.get(), this);
+        worker_thread(), rtc::CreateRandomUuid(), stats_.get());
     audio_sender->SetMediaChannel(voice_media_channel());
     new_sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
         signaling_thread(), audio_sender);
     GetAudioTransceiver()->internal()->AddSender(new_sender);
   } else if (kind == MediaStreamTrackInterface::kVideoKind) {
     auto video_sender =
-        VideoRtpSender::Create(worker_thread(), rtc::CreateRandomUuid(), this);
+        VideoRtpSender::Create(worker_thread(), rtc::CreateRandomUuid());
     video_sender->SetMediaChannel(video_media_channel());
     new_sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
         signaling_thread(), video_sender);
@@ -1738,7 +1738,7 @@
     RTC_LOG(LS_ERROR) << "CreateSender called with invalid kind: " << kind;
     return nullptr;
   }
-  new_sender->internal()->SetStreamIDs(stream_ids);
+  new_sender->internal()->set_stream_ids(stream_ids);
 
   return new_sender;
 }
@@ -2361,7 +2361,7 @@
       } else {
         // Get the StreamParams from the channel which could generate SSRCs.
         const std::vector<StreamParams>& streams = channel->local_streams();
-        transceiver->internal()->sender_internal()->SetStreamIDs(
+        transceiver->internal()->sender_internal()->set_stream_ids(
             streams[0].stream_ids());
         transceiver->internal()->sender_internal()->SetSsrc(
             streams[0].first_ssrc());
@@ -4010,7 +4010,7 @@
   if (sender) {
     // We already have a sender for this track, so just change the stream_id
     // so that it's correct in the next call to CreateOffer.
-    sender->internal()->SetStreamIDs({stream->id()});
+    sender->internal()->set_stream_ids({stream->id()});
     return;
   }
 
@@ -4055,7 +4055,7 @@
   if (sender) {
     // We already have a sender for this track, so just change the stream_id
     // so that it's correct in the next call to CreateOffer.
-    sender->internal()->SetStreamIDs({stream->id()});
+    sender->internal()->set_stream_ids({stream->id()});
     return;
   }
 
@@ -4987,7 +4987,7 @@
     return;
   }
 
-  sender->internal()->SetStreamIDs({sender_info.stream_id});
+  sender->internal()->set_stream_ids({sender_info.stream_id});
   sender->internal()->SetSsrc(sender_info.first_ssrc);
 }
 
@@ -7130,12 +7130,6 @@
   return ret;
 }
 
-void PeerConnection::OnSetStreamIDs() {
-  RTC_DCHECK_RUN_ON(signaling_thread());
-  if (IsUnifiedPlan())
-    UpdateNegotiationNeeded();
-}
-
 PeerConnectionObserver* PeerConnection::Observer() const {
   // In earlier production code, the pointer was not cleared on close,
   // which might have led to undefined behavior if the observer was not
diff --git a/pc/peer_connection.h b/pc/peer_connection.h
index f636c00..3009185 100644
--- a/pc/peer_connection.h
+++ b/pc/peer_connection.h
@@ -25,7 +25,6 @@
 #include "pc/peer_connection_factory.h"
 #include "pc/peer_connection_internal.h"
 #include "pc/rtc_stats_collector.h"
-#include "pc/rtp_sender.h"
 #include "pc/rtp_transceiver.h"
 #include "pc/sctp_transport.h"
 #include "pc/stats_collector.h"
@@ -58,7 +57,6 @@
                        public DataChannelProviderInterface,
                        public DataChannelSink,
                        public JsepTransportController::Observer,
-                       public RtpSenderBase::SetStreamIDsObserver,
                        public rtc::MessageHandler,
                        public sigslot::has_slots<> {
  public:
@@ -1057,9 +1055,6 @@
                           rtc::scoped_refptr<DtlsTransport> dtls_transport,
                           MediaTransportInterface* media_transport) override;
 
-  // RtpSenderBase::SetStreamIDsObserver override.
-  void OnSetStreamIDs() override;
-
   // Returns the observer. Will crash on CHECK if the observer is removed.
   PeerConnectionObserver* Observer() const RTC_RUN_ON(signaling_thread());
 
diff --git a/pc/peer_connection_rtp_unittest.cc b/pc/peer_connection_rtp_unittest.cc
index 8e99727..6925300 100644
--- a/pc/peer_connection_rtp_unittest.cc
+++ b/pc/peer_connection_rtp_unittest.cc
@@ -491,8 +491,15 @@
   ASSERT_TRUE(callee->CreateAnswerAndSetAsLocal());
 
   // Change the stream ID in the offer.
-  caller->pc()->GetSenders()[0]->SetStreamIDs({"stream2"});
-  ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
+  // TODO(https://crbug.com/webrtc/10129): When RtpSenderInterface::SetStreams
+  // is supported, this can use that instead of munging the SDP.
+  auto offer = caller->CreateOffer();
+  auto contents = offer->description()->contents();
+  ASSERT_EQ(1u, contents.size());
+  auto& stream_params = contents[0].media_description()->mutable_streams();
+  ASSERT_EQ(1u, stream_params.size());
+  stream_params[0].set_stream_ids({"stream2"});
+  ASSERT_TRUE(callee->SetRemoteDescription(std::move(offer)));
   ASSERT_EQ(1u, transceiver->receiver()->streams().size());
   EXPECT_EQ("stream2", transceiver->receiver()->streams()[0]->id());
 }
@@ -1790,7 +1797,12 @@
 
 // This test exercises the code path that fires a NegotiationNeeded
 // notification when the stream IDs of the local description differ from
-// the ones in the transceiver.
+// the ones in the transceiver. Since SetStreams() is not yet available
+// on RtpSenderInterface, adding a track is used to trigger the check for
+// the NegotiationNeeded notification.
+// TODO(https://crbug.com/webrtc/10129): Replace this test with a test that
+// checks that calling SetStreams() on a sender fires the notification once
+// the method becomes available in RtpSenderInterface.
 TEST_F(PeerConnectionRtpTestUnifiedPlan,
        ChangeAssociatedStreamsTriggersRenegotiation) {
   auto caller = CreatePeerConnection();
@@ -1805,15 +1817,18 @@
   ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
   caller->observer()->clear_negotiation_needed();
 
-  transceiver->sender()->SetStreamIDs({"stream3", "stream4", "stream5"});
-  EXPECT_TRUE(caller->observer()->negotiation_needed());
+  SessionDescriptionInterface* cld = const_cast<SessionDescriptionInterface*>(
+      caller->pc()->current_local_description());
+  ASSERT_EQ(cld->description()->contents().size(), 1u);
 
-  ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
-  auto callee_streams = callee->pc()->GetReceivers()[0]->streams();
-  ASSERT_EQ(3u, callee_streams.size());
-  EXPECT_EQ("stream3", callee_streams[0]->id());
-  EXPECT_EQ("stream4", callee_streams[1]->id());
-  EXPECT_EQ("stream5", callee_streams[2]->id());
+  cricket::SessionDescription* description = cld->description();
+  cricket::ContentInfo& content_info = description->contents()[0];
+  ASSERT_EQ(content_info.media_description()->mutable_streams().size(), 1u);
+  content_info.media_description()->mutable_streams()[0].set_stream_ids(
+      {"stream3", "stream4", "stream5"});
+
+  ASSERT_TRUE(caller->AddTrack(caller->CreateAudioTrack("a2")));
+  EXPECT_TRUE(caller->observer()->negotiation_needed());
 }
 
 INSTANTIATE_TEST_SUITE_P(PeerConnectionRtpTest,
diff --git a/pc/rtp_sender.cc b/pc/rtp_sender.cc
index 6097034..22957d3 100644
--- a/pc/rtp_sender.cc
+++ b/pc/rtp_sender.cc
@@ -16,7 +16,6 @@
 #include "api/audio_options.h"
 #include "api/media_stream_interface.h"
 #include "media/base/media_engine.h"
-#include "pc/peer_connection.h"
 #include "pc/stats_collector.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/helpers.h"
@@ -119,12 +118,8 @@
   return false;
 }
 
-RtpSenderBase::RtpSenderBase(rtc::Thread* worker_thread,
-                             const std::string& id,
-                             SetStreamIDsObserver* set_stream_ids_observer)
-    : worker_thread_(worker_thread),
-      id_(id),
-      set_stream_ids_observer_(set_stream_ids_observer) {
+RtpSenderBase::RtpSenderBase(rtc::Thread* worker_thread, const std::string& id)
+    : worker_thread_(worker_thread), id_(id) {
   RTC_DCHECK(worker_thread);
   init_parameters_.encodings.emplace_back();
 }
@@ -220,12 +215,6 @@
   return result;
 }
 
-void RtpSenderBase::SetStreamIDs(const std::vector<std::string>& stream_ids) {
-  stream_ids_ = stream_ids;
-  if (set_stream_ids_observer_)
-    set_stream_ids_observer_->OnSetStreamIDs();
-}
-
 bool RtpSenderBase::SetTrack(MediaStreamTrackInterface* track) {
   TRACE_EVENT0("webrtc", "RtpSenderBase::SetTrack");
   if (stopped_) {
@@ -328,7 +317,6 @@
     RemoveTrackFromStats();
   }
   media_channel_ = nullptr;
-  set_stream_ids_observer_ = nullptr;
   stopped_ = true;
 }
 
@@ -407,18 +395,15 @@
 rtc::scoped_refptr<AudioRtpSender> AudioRtpSender::Create(
     rtc::Thread* worker_thread,
     const std::string& id,
-    StatsCollector* stats,
-    SetStreamIDsObserver* set_stream_ids_observer) {
+    StatsCollector* stats) {
   return rtc::scoped_refptr<AudioRtpSender>(
-      new rtc::RefCountedObject<AudioRtpSender>(worker_thread, id, stats,
-                                                set_stream_ids_observer));
+      new rtc::RefCountedObject<AudioRtpSender>(worker_thread, id, stats));
 }
 
 AudioRtpSender::AudioRtpSender(rtc::Thread* worker_thread,
                                const std::string& id,
-                               StatsCollector* stats,
-                               SetStreamIDsObserver* set_stream_ids_observer)
-    : RtpSenderBase(worker_thread, id, set_stream_ids_observer),
+                               StatsCollector* stats)
+    : RtpSenderBase(worker_thread, id),
       stats_(stats),
       dtmf_sender_proxy_(DtmfSenderProxy::Create(
           rtc::Thread::Current(),
@@ -554,17 +539,14 @@
 
 rtc::scoped_refptr<VideoRtpSender> VideoRtpSender::Create(
     rtc::Thread* worker_thread,
-    const std::string& id,
-    SetStreamIDsObserver* set_stream_ids_observer) {
+    const std::string& id) {
   return rtc::scoped_refptr<VideoRtpSender>(
-      new rtc::RefCountedObject<VideoRtpSender>(worker_thread, id,
-                                                set_stream_ids_observer));
+      new rtc::RefCountedObject<VideoRtpSender>(worker_thread, id));
 }
 
 VideoRtpSender::VideoRtpSender(rtc::Thread* worker_thread,
-                               const std::string& id,
-                               SetStreamIDsObserver* set_stream_ids_observer)
-    : RtpSenderBase(worker_thread, id, set_stream_ids_observer) {}
+                               const std::string& id)
+    : RtpSenderBase(worker_thread, id) {}
 
 VideoRtpSender::~VideoRtpSender() {
   Stop();
diff --git a/pc/rtp_sender.h b/pc/rtp_sender.h
index 73c6925..c786d90 100644
--- a/pc/rtp_sender.h
+++ b/pc/rtp_sender.h
@@ -47,7 +47,7 @@
   // description).
   virtual void SetSsrc(uint32_t ssrc) = 0;
 
-  virtual void SetStreamIDs(const std::vector<std::string>& stream_ids) {}
+  virtual void set_stream_ids(const std::vector<std::string>& stream_ids) = 0;
   virtual void set_init_send_encodings(
       const std::vector<RtpEncodingParameters>& init_send_encodings) = 0;
   virtual void set_transport(
@@ -74,12 +74,6 @@
 // Shared implementation for RtpSenderInternal interface.
 class RtpSenderBase : public RtpSenderInternal, public ObserverInterface {
  public:
-  class SetStreamIDsObserver {
-   public:
-    virtual ~SetStreamIDsObserver() = default;
-    virtual void OnSetStreamIDs() = 0;
-  };
-
   // Sets the underlying MediaEngine channel associated with this RtpSender.
   // A VoiceMediaChannel should be used for audio RtpSenders and
   // a VideoMediaChannel should be used for video RtpSenders.
@@ -107,7 +101,9 @@
   uint32_t ssrc() const override { return ssrc_; }
 
   std::vector<std::string> stream_ids() const override { return stream_ids_; }
-  void SetStreamIDs(const std::vector<std::string>& stream_ids) override;
+  void set_stream_ids(const std::vector<std::string>& stream_ids) override {
+    stream_ids_ = stream_ids;
+  }
 
   std::string id() const override { return id_; }
 
@@ -147,12 +143,7 @@
   RTCError DisableEncodingLayers(const std::vector<std::string>& rid) override;
 
  protected:
-  // If |set_stream_ids_observer| is not null, it is invoked when SetStreamIDs
-  // is called. |set_stream_ids_observer| is not owned by this object. If not
-  // null, it must be valid at least until this sender becomes stopped.
-  RtpSenderBase(rtc::Thread* worker_thread,
-                const std::string& id,
-                SetStreamIDsObserver* set_stream_ids_observer);
+  RtpSenderBase(rtc::Thread* worker_thread, const std::string& id);
   // TODO(nisse): Since SSRC == 0 is technically valid, figure out
   // some other way to test if we have a valid SSRC.
   bool can_send_track() const { return track_ && ssrc_; }
@@ -192,8 +183,6 @@
   // const method.
   mutable absl::optional<std::string> last_transaction_id_;
   std::vector<std::string> disabled_rids_;
-
-  SetStreamIDsObserver* set_stream_ids_observer_ = nullptr;
 };
 
 // LocalAudioSinkAdapter receives data callback as a sink to the local
@@ -226,14 +215,9 @@
   // The sender is initialized with no track to send and no associated streams.
   // StatsCollector provided so that Add/RemoveLocalAudioTrack can be called
   // at the appropriate times.
-  // If |set_stream_ids_observer| is not null, it is invoked when SetStreamIDs
-  // is called. |set_stream_ids_observer| is not owned by this object. If not
-  // null, it must be valid at least until this sender becomes stopped.
-  static rtc::scoped_refptr<AudioRtpSender> Create(
-      rtc::Thread* worker_thread,
-      const std::string& id,
-      StatsCollector* stats,
-      SetStreamIDsObserver* set_stream_ids_observer);
+  static rtc::scoped_refptr<AudioRtpSender> Create(rtc::Thread* worker_thread,
+                                                   const std::string& id,
+                                                   StatsCollector* stats);
   virtual ~AudioRtpSender();
 
   // DtmfSenderProvider implementation.
@@ -256,8 +240,7 @@
  protected:
   AudioRtpSender(rtc::Thread* worker_thread,
                  const std::string& id,
-                 StatsCollector* stats,
-                 SetStreamIDsObserver* set_stream_ids_observer);
+                 StatsCollector* stats);
 
   void SetSend() override;
   void ClearSend() override;
@@ -291,13 +274,8 @@
  public:
   // Construct an RtpSender for video with the given sender ID.
   // The sender is initialized with no track to send and no associated streams.
-  // If |set_stream_ids_observer| is not null, it is invoked when SetStreamIDs
-  // is called. |set_stream_ids_observer| is not owned by this object. If not
-  // null, it must be valid at least until this sender becomes stopped.
-  static rtc::scoped_refptr<VideoRtpSender> Create(
-      rtc::Thread* worker_thread,
-      const std::string& id,
-      SetStreamIDsObserver* set_stream_ids_observer);
+  static rtc::scoped_refptr<VideoRtpSender> Create(rtc::Thread* worker_thread,
+                                                   const std::string& id);
   virtual ~VideoRtpSender();
 
   // ObserverInterface implementation
@@ -313,9 +291,7 @@
   rtc::scoped_refptr<DtmfSenderInterface> GetDtmfSender() const override;
 
  protected:
-  VideoRtpSender(rtc::Thread* worker_thread,
-                 const std::string& id,
-                 SetStreamIDsObserver* set_stream_ids_observer);
+  VideoRtpSender(rtc::Thread* worker_thread, const std::string& id);
 
   void SetSend() override;
   void ClearSend() override;
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index be8c472..90ca03f 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -83,13 +83,6 @@
 static const uint32_t kVideoSsrcSimulcast = 102;
 static const uint32_t kVideoSimulcastLayerCount = 2;
 static const int kDefaultTimeout = 10000;  // 10 seconds.
-
-class MockSetStreamIDsObserver
-    : public webrtc::RtpSenderBase::SetStreamIDsObserver {
- public:
-  MOCK_METHOD0(OnSetStreamIDs, void());
-};
-
 }  // namespace
 
 namespace webrtc {
@@ -194,14 +187,10 @@
       const rtc::scoped_refptr<LocalAudioSource>& source) {
     audio_track_ = AudioTrack::Create(kAudioTrackId, source);
     EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
-    std::unique_ptr<MockSetStreamIDsObserver> set_stream_ids_observer =
-        absl::make_unique<MockSetStreamIDsObserver>();
     audio_rtp_sender_ =
-        AudioRtpSender::Create(worker_thread_, audio_track_->id(), nullptr,
-                               set_stream_ids_observer.get());
+        AudioRtpSender::Create(worker_thread_, audio_track_->id(), nullptr);
     ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_));
-    EXPECT_CALL(*set_stream_ids_observer, OnSetStreamIDs());
-    audio_rtp_sender_->SetStreamIDs({local_stream_->id()});
+    audio_rtp_sender_->set_stream_ids({local_stream_->id()});
     audio_rtp_sender_->SetMediaChannel(voice_media_channel_);
     audio_rtp_sender_->SetSsrc(kAudioSsrc);
     audio_rtp_sender_->GetOnDestroyedSignal()->connect(
@@ -211,7 +200,7 @@
 
   void CreateAudioRtpSenderWithNoTrack() {
     audio_rtp_sender_ =
-        AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr);
+        AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
     audio_rtp_sender_->SetMediaChannel(voice_media_channel_);
   }
 
@@ -259,20 +248,16 @@
 
   void CreateVideoRtpSender(bool is_screencast, uint32_t ssrc = kVideoSsrc) {
     AddVideoTrack(is_screencast);
-    std::unique_ptr<MockSetStreamIDsObserver> set_stream_ids_observer =
-        absl::make_unique<MockSetStreamIDsObserver>();
-    video_rtp_sender_ = VideoRtpSender::Create(
-        worker_thread_, video_track_->id(), set_stream_ids_observer.get());
+    video_rtp_sender_ =
+        VideoRtpSender::Create(worker_thread_, video_track_->id());
     ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_));
-    EXPECT_CALL(*set_stream_ids_observer, OnSetStreamIDs());
-    video_rtp_sender_->SetStreamIDs({local_stream_->id()});
+    video_rtp_sender_->set_stream_ids({local_stream_->id()});
     video_rtp_sender_->SetMediaChannel(video_media_channel_);
     video_rtp_sender_->SetSsrc(ssrc);
     VerifyVideoChannelInput(ssrc);
   }
   void CreateVideoRtpSenderWithNoTrack() {
-    video_rtp_sender_ =
-        VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
+    video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, /*id=*/"");
     video_rtp_sender_->SetMediaChannel(video_media_channel_);
   }
 
@@ -443,7 +428,7 @@
   void RunDisableSimulcastLayersWithoutMediaEngineTest(
       const std::vector<std::string>& all_layers,
       const std::vector<std::string>& disabled_layers) {
-    auto sender = VideoRtpSender::Create(rtc::Thread::Current(), "1", nullptr);
+    auto sender = VideoRtpSender::Create(rtc::Thread::Current(), "1");
     RtpParameters parameters;
     parameters.encodings.resize(all_layers.size());
     for (size_t i = 0; i < all_layers.size(); ++i) {
@@ -835,7 +820,7 @@
 
 TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParametersBeforeNegotiation) {
   audio_rtp_sender_ =
-      AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr);
+      AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
 
   RtpParameters params = audio_rtp_sender_->GetParameters();
   ASSERT_EQ(1u, params.encodings.size());
@@ -853,14 +838,10 @@
   audio_track_ = AudioTrack::Create(kAudioTrackId, nullptr);
   EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
 
-  std::unique_ptr<MockSetStreamIDsObserver> set_stream_ids_observer =
-      absl::make_unique<MockSetStreamIDsObserver>();
   audio_rtp_sender_ =
-      AudioRtpSender::Create(worker_thread_, audio_track_->id(), nullptr,
-                             set_stream_ids_observer.get());
+      AudioRtpSender::Create(worker_thread_, audio_track_->id(), nullptr);
   ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_));
-  EXPECT_CALL(*set_stream_ids_observer, OnSetStreamIDs());
-  audio_rtp_sender_->SetStreamIDs({local_stream_->id()});
+  audio_rtp_sender_->set_stream_ids({local_stream_->id()});
 
   std::vector<RtpEncodingParameters> init_encodings(1);
   init_encodings[0].max_bitrate_bps = 60000;
@@ -888,7 +869,7 @@
 TEST_F(RtpSenderReceiverTest,
        AudioSenderMustCallGetParametersBeforeSetParametersBeforeNegotiation) {
   audio_rtp_sender_ =
-      AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr);
+      AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
 
   RtpParameters params;
   RTCError result = audio_rtp_sender_->SetParameters(params);
@@ -1067,8 +1048,7 @@
 }
 
 TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParametersBeforeNegotiation) {
-  video_rtp_sender_ =
-      VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
+  video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, /*id=*/"");
 
   RtpParameters params = video_rtp_sender_->GetParameters();
   ASSERT_EQ(1u, params.encodings.size());
@@ -1085,13 +1065,10 @@
 TEST_F(RtpSenderReceiverTest, VideoSenderInitParametersMovedAfterNegotiation) {
   AddVideoTrack(false);
 
-  std::unique_ptr<MockSetStreamIDsObserver> set_stream_ids_observer =
-      absl::make_unique<MockSetStreamIDsObserver>();
-  video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(),
-                                             set_stream_ids_observer.get());
+  video_rtp_sender_ =
+      VideoRtpSender::Create(worker_thread_, video_track_->id());
   ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_));
-  EXPECT_CALL(*set_stream_ids_observer, OnSetStreamIDs());
-  video_rtp_sender_->SetStreamIDs({local_stream_->id()});
+  video_rtp_sender_->set_stream_ids({local_stream_->id()});
 
   std::vector<RtpEncodingParameters> init_encodings(2);
   init_encodings[0].max_bitrate_bps = 60000;
@@ -1126,13 +1103,10 @@
        VideoSenderInitParametersMovedAfterManualSimulcastAndNegotiation) {
   AddVideoTrack(false);
 
-  std::unique_ptr<MockSetStreamIDsObserver> set_stream_ids_observer =
-      absl::make_unique<MockSetStreamIDsObserver>();
-  video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(),
-                                             set_stream_ids_observer.get());
+  video_rtp_sender_ =
+      VideoRtpSender::Create(worker_thread_, video_track_->id());
   ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_));
-  EXPECT_CALL(*set_stream_ids_observer, OnSetStreamIDs());
-  video_rtp_sender_->SetStreamIDs({local_stream_->id()});
+  video_rtp_sender_->set_stream_ids({local_stream_->id()});
 
   std::vector<RtpEncodingParameters> init_encodings(1);
   init_encodings[0].max_bitrate_bps = 60000;
@@ -1163,8 +1137,7 @@
 
 TEST_F(RtpSenderReceiverTest,
        VideoSenderMustCallGetParametersBeforeSetParametersBeforeNegotiation) {
-  video_rtp_sender_ =
-      VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
+  video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, /*id=*/"");
 
   RtpParameters params;
   RTCError result = video_rtp_sender_->SetParameters(params);
@@ -1554,16 +1527,13 @@
 TEST_F(RtpSenderReceiverTest,
        PropagatesVideoTrackContentHintSetBeforeEnabling) {
   AddVideoTrack();
-  std::unique_ptr<MockSetStreamIDsObserver> set_stream_ids_observer =
-      absl::make_unique<MockSetStreamIDsObserver>();
   // Setting detailed overrides the default non-screencast mode. This should be
   // applied even if the track is set on construction.
   video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
-  video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(),
-                                             set_stream_ids_observer.get());
+  video_rtp_sender_ =
+      VideoRtpSender::Create(worker_thread_, video_track_->id());
   ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_));
-  EXPECT_CALL(*set_stream_ids_observer, OnSetStreamIDs());
-  video_rtp_sender_->SetStreamIDs({local_stream_->id()});
+  video_rtp_sender_->set_stream_ids({local_stream_->id()});
   video_rtp_sender_->SetMediaChannel(video_media_channel_);
   video_track_->set_enabled(true);
 
diff --git a/pc/test/mock_rtp_sender_internal.h b/pc/test/mock_rtp_sender_internal.h
index 181dcbb..fa16220 100644
--- a/pc/test/mock_rtp_sender_internal.h
+++ b/pc/test/mock_rtp_sender_internal.h
@@ -46,7 +46,7 @@
   // RtpSenderInternal methods.
   MOCK_METHOD1(SetMediaChannel, void(cricket::MediaChannel*));
   MOCK_METHOD1(SetSsrc, void(uint32_t));
-  MOCK_METHOD1(SetStreamIDs, void(const std::vector<std::string>&));
+  MOCK_METHOD1(set_stream_ids, void(const std::vector<std::string>&));
   MOCK_METHOD1(set_init_send_encodings,
                void(const std::vector<RtpEncodingParameters>&));
   MOCK_METHOD0(Stop, void());