diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc
index 0852a7b..5d2d1f1 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -480,24 +480,33 @@
   RTC_DCHECK(!registered_for_feedback_);
 }
 
-void RtpVideoSender::Stop() {
+void RtpVideoSender::SetActive(bool active) {
   RTC_DCHECK_RUN_ON(&transport_checker_);
   MutexLock lock(&mutex_);
-  if (!active_)
+  if (active_ == active)
     return;
 
-  const std::vector<bool> active_modules(rtp_streams_.size(), false);
+  const std::vector<bool> active_modules(rtp_streams_.size(), active);
   SetActiveModulesLocked(active_modules);
+
+  auto* feedback_provider = transport_->GetStreamFeedbackProvider();
+  if (active && !registered_for_feedback_) {
+    feedback_provider->RegisterStreamFeedbackObserver(rtp_config_.ssrcs, this);
+    registered_for_feedback_ = true;
+  } else if (!active && registered_for_feedback_) {
+    feedback_provider->DeRegisterStreamFeedbackObserver(this);
+    registered_for_feedback_ = false;
+  }
 }
 
-void RtpVideoSender::SetActiveModules(const std::vector<bool>& active_modules) {
+void RtpVideoSender::SetActiveModules(const std::vector<bool> active_modules) {
   RTC_DCHECK_RUN_ON(&transport_checker_);
   MutexLock lock(&mutex_);
   return SetActiveModulesLocked(active_modules);
 }
 
 void RtpVideoSender::SetActiveModulesLocked(
-    const std::vector<bool>& active_modules) {
+    const std::vector<bool> active_modules) {
   RTC_DCHECK_RUN_ON(&transport_checker_);
   RTC_DCHECK_EQ(rtp_streams_.size(), active_modules.size());
   active_ = false;
@@ -529,17 +538,6 @@
                                                     /*remb_candidate=*/true);
     }
   }
-  if (!active_) {
-    auto* feedback_provider = transport_->GetStreamFeedbackProvider();
-    if (registered_for_feedback_) {
-      feedback_provider->DeRegisterStreamFeedbackObserver(this);
-      registered_for_feedback_ = false;
-    }
-  } else if (!registered_for_feedback_) {
-    auto* feedback_provider = transport_->GetStreamFeedbackProvider();
-    feedback_provider->RegisterStreamFeedbackObserver(rtp_config_.ssrcs, this);
-    registered_for_feedback_ = true;
-  }
 }
 
 bool RtpVideoSender::IsActive() {
diff --git a/call/rtp_video_sender.h b/call/rtp_video_sender.h
index 9b88916..9804bd8 100644
--- a/call/rtp_video_sender.h
+++ b/call/rtp_video_sender.h
@@ -95,11 +95,13 @@
   RtpVideoSender(const RtpVideoSender&) = delete;
   RtpVideoSender& operator=(const RtpVideoSender&) = delete;
 
+  // RtpVideoSender will only route packets if being active, all packets will be
+  // dropped otherwise.
+  void SetActive(bool active) RTC_LOCKS_EXCLUDED(mutex_) override;
   // Sets the sending status of the rtp modules and appropriately sets the
   // payload router to active if any rtp modules are active.
-  void SetActiveModules(const std::vector<bool>& active_modules)
+  void SetActiveModules(std::vector<bool> active_modules)
       RTC_LOCKS_EXCLUDED(mutex_) override;
-  void Stop() RTC_LOCKS_EXCLUDED(mutex_) override;
   bool IsActive() RTC_LOCKS_EXCLUDED(mutex_) override;
 
   void OnNetworkAvailability(bool network_available)
@@ -155,7 +157,7 @@
 
  private:
   bool IsActiveLocked() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-  void SetActiveModulesLocked(const std::vector<bool>& active_modules)
+  void SetActiveModulesLocked(std::vector<bool> active_modules)
       RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   void UpdateModuleSendingState() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   void ConfigureProtection();
diff --git a/call/rtp_video_sender_interface.h b/call/rtp_video_sender_interface.h
index 3f28771..acb68e3 100644
--- a/call/rtp_video_sender_interface.h
+++ b/call/rtp_video_sender_interface.h
@@ -31,12 +31,12 @@
 class RtpVideoSenderInterface : public EncodedImageCallback,
                                 public FecControllerOverride {
  public:
+  // RtpVideoSender will only route packets if being active, all
+  // packets will be dropped otherwise.
+  virtual void SetActive(bool active) = 0;
   // Sets the sending status of the rtp modules and appropriately sets the
   // RtpVideoSender to active if any rtp modules are active.
-  // A module will only send packet if beeing active.
-  virtual void SetActiveModules(const std::vector<bool>& active_modules) = 0;
-  // Set the sending status of all rtp modules to inactive.
-  virtual void Stop() = 0;
+  virtual void SetActiveModules(std::vector<bool> active_modules) = 0;
   virtual bool IsActive() = 0;
 
   virtual void OnNetworkAvailability(bool network_available) = 0;
diff --git a/call/rtp_video_sender_unittest.cc b/call/rtp_video_sender_unittest.cc
index a8595e3..3ce9ca2 100644
--- a/call/rtp_video_sender_unittest.cc
+++ b/call/rtp_video_sender_unittest.cc
@@ -187,14 +187,14 @@
                                   /*frame_transformer=*/nullptr,
                                   field_trials) {}
 
-  ~RtpVideoSenderTestFixture() { Stop(); }
+  ~RtpVideoSenderTestFixture() { SetActive(false); }
 
   RtpVideoSender* router() { return router_.get(); }
   MockTransport& transport() { return transport_; }
   void AdvanceTime(TimeDelta delta) { time_controller_.AdvanceTime(delta); }
 
-  void Stop() {
-    RunOnTransportQueue([&]() { router_->Stop(); });
+  void SetActive(bool active) {
+    RunOnTransportQueue([&]() { router_->SetActive(active); });
   }
 
   void SetActiveModules(const std::vector<bool>& active_modules) {
@@ -249,15 +249,15 @@
   EXPECT_NE(EncodedImageCallback::Result::OK,
             test.router()->OnEncodedImage(encoded_image, nullptr).error);
 
-  test.SetActiveModules({true});
+  test.SetActive(true);
   EXPECT_EQ(EncodedImageCallback::Result::OK,
             test.router()->OnEncodedImage(encoded_image, nullptr).error);
 
-  test.SetActiveModules({false});
+  test.SetActive(false);
   EXPECT_NE(EncodedImageCallback::Result::OK,
             test.router()->OnEncodedImage(encoded_image, nullptr).error);
 
-  test.SetActiveModules({true});
+  test.SetActive(true);
   EXPECT_EQ(EncodedImageCallback::Result::OK,
             test.router()->OnEncodedImage(encoded_image, nullptr).error);
 }
@@ -276,7 +276,7 @@
   CodecSpecificInfo codec_info;
   codec_info.codecType = kVideoCodecVP8;
 
-  test.SetActiveModules({true, true});
+  test.SetActive(true);
   EXPECT_EQ(EncodedImageCallback::Result::OK,
             test.router()->OnEncodedImage(encoded_image_1, &codec_info).error);
 
@@ -286,7 +286,7 @@
             test.router()->OnEncodedImage(encoded_image_2, &codec_info).error);
 
   // Inactive.
-  test.Stop();
+  test.SetActive(false);
   EXPECT_NE(EncodedImageCallback::Result::OK,
             test.router()->OnEncodedImage(encoded_image_1, &codec_info).error);
   EXPECT_NE(EncodedImageCallback::Result::OK,
@@ -370,7 +370,7 @@
 TEST(RtpVideoSenderTest, CreateWithNoPreviousStates) {
   RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2},
                                  kPayloadType, {});
-  test.SetActiveModules({true, true});
+  test.SetActive(true);
 
   std::map<uint32_t, RtpPayloadState> initial_states =
       test.router()->GetRtpPayloadStates();
@@ -395,7 +395,7 @@
 
   RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2},
                                  kPayloadType, states);
-  test.SetActiveModules({true, true});
+  test.SetActive(true);
 
   std::map<uint32_t, RtpPayloadState> initial_states =
       test.router()->GetRtpPayloadStates();
@@ -435,7 +435,7 @@
             test.router()->OnEncodedImage(encoded_image, nullptr).error);
   ::testing::Mock::VerifyAndClearExpectations(&callback);
 
-  test.SetActiveModules({true});
+  test.SetActive(true);
 
   FrameCounts frame_counts;
   EXPECT_CALL(callback, FrameCountUpdated(_, kSsrc1))
@@ -464,7 +464,7 @@
 TEST(RtpVideoSenderTest, DoesNotRetrasmitAckedPackets) {
   RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2},
                                  kPayloadType, {});
-  test.SetActiveModules({true, true});
+  test.SetActive(true);
 
   constexpr uint8_t kPayload = 'a';
   EncodedImage encoded_image;
@@ -629,7 +629,7 @@
 TEST(RtpVideoSenderTest, EarlyRetransmits) {
   RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2},
                                  kPayloadType, {});
-  test.SetActiveModules({true, true});
+  test.SetActive(true);
 
   const uint8_t kPayload[1] = {'a'};
   EncodedImage encoded_image;
@@ -724,7 +724,7 @@
 
 TEST(RtpVideoSenderTest, SupportsDependencyDescriptor) {
   RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {});
-  test.SetActiveModules({true});
+  test.SetActive(true);
 
   RtpHeaderExtensionMap extensions;
   extensions.Register<RtpDependencyDescriptorExtension>(
@@ -797,7 +797,7 @@
                 sent_packets.emplace_back(&extensions).Parse(packet, length));
             return true;
           });
-  test.SetActiveModules({true});
+  test.SetActive(true);
 
   EncodedImage key_frame_image;
   key_frame_image._frameType = VideoFrameType::kVideoFrameKey;
@@ -831,7 +831,7 @@
 
 TEST(RtpVideoSenderTest, SupportsDependencyDescriptorForVp9) {
   RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {});
-  test.SetActiveModules({true});
+  test.SetActive(true);
 
   RtpHeaderExtensionMap extensions;
   extensions.Register<RtpDependencyDescriptorExtension>(
@@ -887,7 +887,7 @@
 TEST(RtpVideoSenderTest,
      SupportsDependencyDescriptorForVp9NotProvidedByEncoder) {
   RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {});
-  test.SetActiveModules({true});
+  test.SetActive(true);
 
   RtpHeaderExtensionMap extensions;
   extensions.Register<RtpDependencyDescriptorExtension>(
@@ -942,7 +942,7 @@
   test::ScopedKeyValueConfig field_trials(
       "WebRTC-GenericCodecDependencyDescriptor/Enabled/");
   RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}, &field_trials);
-  test.SetActiveModules({true});
+  test.SetActive(true);
 
   RtpHeaderExtensionMap extensions;
   extensions.Register<RtpDependencyDescriptorExtension>(
@@ -988,7 +988,7 @@
 
 TEST(RtpVideoSenderTest, SupportsStoppingUsingDependencyDescriptor) {
   RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {});
-  test.SetActiveModules({true});
+  test.SetActive(true);
 
   RtpHeaderExtensionMap extensions;
   extensions.Register<RtpDependencyDescriptorExtension>(
@@ -1073,7 +1073,7 @@
       kRtpHeaderSizeBytes + kTransportPacketOverheadBytes;
   RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}, &field_trials);
   test.router()->OnTransportOverheadChanged(kTransportPacketOverheadBytes);
-  test.SetActiveModules({true});
+  test.SetActive(true);
 
   {
     test.router()->OnBitrateUpdated(CreateBitrateAllocationUpdate(300000),
diff --git a/call/video_send_stream.h b/call/video_send_stream.h
index 9608281..e54a51d 100644
--- a/call/video_send_stream.h
+++ b/call/video_send_stream.h
@@ -216,15 +216,11 @@
   // Note: This starts stream activity if it is inactive and one of the layers
   // is active. This stops stream activity if it is active and all layers are
   // inactive.
-  // `active_layers` should have the same size as the number of configured
-  // simulcast layers or one if only one rtp stream is used.
-  virtual void StartPerRtpStream(std::vector<bool> active_layers) = 0;
+  virtual void UpdateActiveSimulcastLayers(std::vector<bool> active_layers) = 0;
 
   // Starts stream activity.
   // When a stream is active, it can receive, process and deliver packets.
-  // Prefer to use StartPerRtpStream.
   virtual void Start() = 0;
-
   // Stops stream activity.
   // When a stream is stopped, it can't receive, process or deliver packets.
   virtual void Stop() = 0;
@@ -232,9 +228,9 @@
   // Accessor for determining if the stream is active. This is an inexpensive
   // call that must be made on the same thread as `Start()` and `Stop()` methods
   // are called on and will return `true` iff activity has been started either
-  // via `Start()` or `StartPerRtpStream()`. If activity is either
+  // via `Start()` or `UpdateActiveSimulcastLayers()`. If activity is either
   // stopped or is in the process of being stopped as a result of a call to
-  // either `Stop()` or `StartPerRtpStream()` where all layers were
+  // either `Stop()` or `UpdateActiveSimulcastLayers()` where all layers were
   // deactivated, the return value will be `false`.
   virtual bool started() = 0;
 
diff --git a/media/engine/fake_webrtc_call.cc b/media/engine/fake_webrtc_call.cc
index 8046c3a..063be93 100644
--- a/media/engine/fake_webrtc_call.cc
+++ b/media/engine/fake_webrtc_call.cc
@@ -338,7 +338,7 @@
   webrtc::InvokeSetParametersCallback(callback, webrtc::RTCError::OK());
 }
 
-void FakeVideoSendStream::StartPerRtpStream(
+void FakeVideoSendStream::UpdateActiveSimulcastLayers(
     const std::vector<bool> active_layers) {
   sending_ = false;
   for (const bool active_layer : active_layers) {
diff --git a/media/engine/fake_webrtc_call.h b/media/engine/fake_webrtc_call.h
index 370b707..a3876b3 100644
--- a/media/engine/fake_webrtc_call.h
+++ b/media/engine/fake_webrtc_call.h
@@ -202,7 +202,7 @@
   void OnFrame(const webrtc::VideoFrame& frame) override;
 
   // webrtc::VideoSendStream implementation.
-  void StartPerRtpStream(std::vector<bool> active_layers) override;
+  void UpdateActiveSimulcastLayers(std::vector<bool> active_layers) override;
   void Start() override;
   void Stop() override;
   bool started() override { return IsSending(); }
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index d4bdeff..8dfc46c 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -2439,7 +2439,7 @@
     }
     // This updates what simulcast layers are sending, and possibly starts
     // or stops the VideoSendStream.
-    stream_->StartPerRtpStream(active_layers);
+    stream_->UpdateActiveSimulcastLayers(active_layers);
   } else {
     if (stream_ != nullptr) {
       stream_->Stop();
@@ -2846,7 +2846,7 @@
 
   parameters_.encoder_config.encoder_specific_settings = NULL;
 
-  // Calls stream_->StartPerRtpStream() to start the VideoSendStream
+  // Calls stream_->UpdateActiveSimulcastLayers() to start the VideoSendStream
   // if necessary conditions are met.
   UpdateSendState();
 
diff --git a/test/call_test.cc b/test/call_test.cc
index 156b8a7..7e7c9bb 100644
--- a/test/call_test.cc
+++ b/test/call_test.cc
@@ -591,11 +591,8 @@
 }
 
 void CallTest::StartVideoStreams() {
-  for (size_t i = 0; i < video_send_streams_.size(); ++i) {
-    std::vector<bool> active_rtp_streams(
-        video_send_configs_[i].rtp.ssrcs.size(), true);
-    video_send_streams_[i]->StartPerRtpStream(active_rtp_streams);
-  }
+  for (VideoSendStream* video_send_stream : video_send_streams_)
+    video_send_stream->Start();
   for (VideoReceiveStreamInterface* video_recv_stream : video_receive_streams_)
     video_recv_stream->Start();
 }
diff --git a/test/scenario/video_stream.cc b/test/scenario/video_stream.cc
index 96ced83..ad352f9 100644
--- a/test/scenario/video_stream.cc
+++ b/test/scenario/video_stream.cc
@@ -480,7 +480,7 @@
     MutexLock lock(&mutex_);
     if (config_.encoder.codec ==
         VideoStreamConfig::Encoder::Codec::kVideoCodecVP8) {
-      send_stream_->StartPerRtpStream(active_layers);
+      send_stream_->UpdateActiveSimulcastLayers(active_layers);
     }
     VideoEncoderConfig encoder_config = CreateVideoEncoderConfig(config_);
     RTC_CHECK_EQ(encoder_config.simulcast_layers.size(), active_layers.size());
diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc
index e5545e7..30598c1 100644
--- a/video/video_send_stream.cc
+++ b/video/video_send_stream.cc
@@ -209,12 +209,8 @@
   transport_->DestroyRtpVideoSender(rtp_video_sender_);
 }
 
-void VideoSendStream::Start() {
-  const std::vector<bool> active_layers(config_.rtp.ssrcs.size(), true);
-  StartPerRtpStream(active_layers);
-}
-
-void VideoSendStream::StartPerRtpStream(const std::vector<bool> active_layers) {
+void VideoSendStream::UpdateActiveSimulcastLayers(
+    const std::vector<bool> active_layers) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
 
   // Keep our `running_` flag expected state in sync with active layers since
@@ -236,16 +232,35 @@
     }
   }
   active_layers_string << "}";
-  RTC_LOG(LS_INFO) << "StartPerRtpStream: " << active_layers_string.str();
+  RTC_LOG(LS_INFO) << "UpdateActiveSimulcastLayers: "
+                   << active_layers_string.str();
 
   rtp_transport_queue_->RunOrPost(
       SafeTask(transport_queue_safety_, [this, active_layers] {
-        send_stream_.StartPerRtpStream(active_layers);
+        send_stream_.UpdateActiveSimulcastLayers(active_layers);
       }));
 
   running_ = running;
 }
 
+void VideoSendStream::Start() {
+  RTC_DCHECK_RUN_ON(&thread_checker_);
+  RTC_DLOG(LS_INFO) << "VideoSendStream::Start";
+  if (running_)
+    return;
+
+  running_ = true;
+
+  // It is expected that after VideoSendStream::Start has been called, incoming
+  // frames are not dropped in VideoStreamEncoder. To ensure this, Start has to
+  // be synchronized.
+  // TODO(tommi): ^^^ Validate if this still holds.
+  rtp_transport_queue_->RunSynchronous([this] {
+    transport_queue_safety_->SetAlive();
+    send_stream_.Start();
+  });
+}
+
 void VideoSendStream::Stop() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   if (!running_)
diff --git a/video/video_send_stream.h b/video/video_send_stream.h
index a7ce112..a052b85 100644
--- a/video/video_send_stream.h
+++ b/video/video_send_stream.h
@@ -78,8 +78,8 @@
   void DeliverRtcp(const uint8_t* packet, size_t length);
 
   // webrtc::VideoSendStream implementation.
+  void UpdateActiveSimulcastLayers(std::vector<bool> active_layers) override;
   void Start() override;
-  void StartPerRtpStream(std::vector<bool> active_layers) override;
   void Stop() override;
   bool started() override;
 
diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc
index f34388e..06f6a05 100644
--- a/video/video_send_stream_impl.cc
+++ b/video/video_send_stream_impl.cc
@@ -312,18 +312,31 @@
   rtp_video_sender_->DeliverRtcp(packet, length);
 }
 
-void VideoSendStreamImpl::StartPerRtpStream(
+void VideoSendStreamImpl::UpdateActiveSimulcastLayers(
     const std::vector<bool> active_layers) {
   RTC_DCHECK_RUN_ON(rtp_transport_queue_);
   bool previously_active = rtp_video_sender_->IsActive();
   rtp_video_sender_->SetActiveModules(active_layers);
   if (!rtp_video_sender_->IsActive() && previously_active) {
+    // Payload router switched from active to inactive.
     StopVideoSendStream();
   } else if (rtp_video_sender_->IsActive() && !previously_active) {
+    // Payload router switched from inactive to active.
     StartupVideoSendStream();
   }
 }
 
+void VideoSendStreamImpl::Start() {
+  RTC_DCHECK_RUN_ON(rtp_transport_queue_);
+  RTC_LOG(LS_INFO) << "VideoSendStream::Start";
+  if (rtp_video_sender_->IsActive())
+    return;
+
+  TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Start");
+  rtp_video_sender_->SetActive(true);
+  StartupVideoSendStream();
+}
+
 void VideoSendStreamImpl::StartupVideoSendStream() {
   RTC_DCHECK_RUN_ON(rtp_transport_queue_);
   transport_queue_safety_->SetAlive();
@@ -365,7 +378,7 @@
 
   RTC_DCHECK(transport_queue_safety_->alive());
   TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Stop");
-  rtp_video_sender_->Stop();
+  rtp_video_sender_->SetActive(false);
   StopVideoSendStream();
 }
 
diff --git a/video/video_send_stream_impl.h b/video/video_send_stream_impl.h
index f145450..d444eab 100644
--- a/video/video_send_stream_impl.h
+++ b/video/video_send_stream_impl.h
@@ -79,7 +79,8 @@
   ~VideoSendStreamImpl() override;
 
   void DeliverRtcp(const uint8_t* packet, size_t length);
-  void StartPerRtpStream(std::vector<bool> active_layers);
+  void UpdateActiveSimulcastLayers(std::vector<bool> active_layers);
+  void Start();
   void Stop();
 
   // TODO(holmer): Move these to RtpTransportControllerSend.
diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc
index c38dcd0..8a88ba0 100644
--- a/video/video_send_stream_impl_unittest.cc
+++ b/video/video_send_stream_impl_unittest.cc
@@ -66,8 +66,8 @@
 }
 class MockRtpVideoSender : public RtpVideoSenderInterface {
  public:
-  MOCK_METHOD(void, SetActiveModules, (const std::vector<bool>&), (override));
-  MOCK_METHOD(void, Stop, (), (override));
+  MOCK_METHOD(void, SetActive, (bool), (override));
+  MOCK_METHOD(void, SetActiveModules, (const std::vector<bool>), (override));
   MOCK_METHOD(bool, IsActive, (), (override));
   MOCK_METHOD(void, OnNetworkAvailability, (bool), (override));
   MOCK_METHOD((std::map<uint32_t, RtpState>),
@@ -139,19 +139,12 @@
         .WillRepeatedly(Return(&packet_router_));
     EXPECT_CALL(transport_controller_, CreateRtpVideoSender)
         .WillRepeatedly(Return(&rtp_video_sender_));
-    ON_CALL(rtp_video_sender_, Stop()).WillByDefault(::testing::Invoke([&] {
-      active_modules_.clear();
-    }));
-    ON_CALL(rtp_video_sender_, IsActive())
-        .WillByDefault(::testing::Invoke([&]() {
-          for (bool enabled : active_modules_) {
-            if (enabled)
-              return true;
-          }
-          return false;
-        }));
-    ON_CALL(rtp_video_sender_, SetActiveModules)
-        .WillByDefault(::testing::SaveArg<0>(&active_modules_));
+    EXPECT_CALL(rtp_video_sender_, SetActive(_))
+        .WillRepeatedly(::testing::Invoke(
+            [&](bool active) { rtp_video_sender_active_ = active; }));
+    EXPECT_CALL(rtp_video_sender_, IsActive())
+        .WillRepeatedly(
+            ::testing::Invoke([&]() { return rtp_video_sender_active_; }));
     ON_CALL(transport_controller_, GetWorkerQueue())
         .WillByDefault(Return(&worker_queue_));
   }
@@ -190,8 +183,8 @@
   NiceMock<MockBitrateAllocator> bitrate_allocator_;
   NiceMock<MockVideoStreamEncoder> video_stream_encoder_;
   NiceMock<MockRtpVideoSender> rtp_video_sender_;
-  std::vector<bool> active_modules_;
 
+  bool rtp_video_sender_active_ = false;
   RtcEventLogNull event_log_;
   VideoSendStream::Config config_;
   SendDelayStats send_delay_stats_;
@@ -217,7 +210,7 @@
             EXPECT_EQ(config.bitrate_priority, kDefaultBitratePriority);
           }));
   worker_queue_.RunSynchronous([&] {
-    vss_impl->StartPerRtpStream({true});
+    vss_impl->Start();
     EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get())).Times(1);
     vss_impl->Stop();
   });
@@ -232,7 +225,7 @@
       kDefaultInitialBitrateBps, kDefaultBitratePriority,
       VideoEncoderConfig::ContentType::kRealtimeVideo);
 
-  worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+  worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
 
   // QVGA + VGA configuration matching defaults in
   // media/engine/simulcast.cc.
@@ -298,7 +291,7 @@
   auto vss_impl = CreateVideoSendStreamImpl(
       kDefaultInitialBitrateBps, kDefaultBitratePriority,
       VideoEncoderConfig::ContentType::kScreen);
-  worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+  worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
 
   // Simulcast screenshare.
   VideoStream low_stream;
@@ -364,7 +357,7 @@
       kDefaultInitialBitrateBps, kDefaultBitratePriority,
       VideoEncoderConfig::ContentType::kRealtimeVideo);
 
-  worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+  worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
   // 2-layer video simulcast.
   VideoStream low_stream;
   low_stream.width = 320;
@@ -429,7 +422,7 @@
       kDefaultInitialBitrateBps, kDefaultBitratePriority,
       VideoEncoderConfig::ContentType::kScreen);
   worker_queue_.RunSynchronous([&] {
-    vss_impl->StartPerRtpStream({true});
+    vss_impl->Start();
     vss_impl->Stop();
   });
 }
@@ -441,7 +434,7 @@
       VideoEncoderConfig::ContentType::kScreen);
   worker_queue_.RunSynchronous([&] {
     EXPECT_CALL(transport_controller_, SetPacingFactor(_)).Times(0);
-    vss_impl->StartPerRtpStream({true});
+    vss_impl->Start();
     vss_impl->Stop();
   });
 }
@@ -454,7 +447,7 @@
   EXPECT_CALL(transport_controller_, SetPacingFactor(_)).Times(0);
   VideoStreamEncoderInterface::EncoderSink* const sink =
       static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get());
-  worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+  worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
   // Populate a test instance of video bitrate allocation.
   VideoBitrateAllocation alloc;
   alloc.SetBitrate(0, 0, 10000);
@@ -501,7 +494,7 @@
       kDefaultInitialBitrateBps, kDefaultBitratePriority,
       VideoEncoderConfig::ContentType::kScreen);
   worker_queue_.RunSynchronous([&] {
-    vss_impl->StartPerRtpStream({true});
+    vss_impl->Start();
     // Unpause encoder, to allows allocations to be passed through.
     const uint32_t kBitrateBps = 100000;
     EXPECT_CALL(rtp_video_sender_, GetPayloadBitrateBps())
@@ -563,7 +556,7 @@
       VideoEncoderConfig::ContentType::kScreen);
 
   worker_queue_.RunSynchronous([&] {
-    vss_impl->StartPerRtpStream({true});
+    vss_impl->Start();
     // Unpause encoder, to allows allocations to be passed through.
     const uint32_t kBitrateBps = 100000;
     EXPECT_CALL(rtp_video_sender_, GetPayloadBitrateBps())
@@ -606,7 +599,7 @@
       kDefaultInitialBitrateBps, kDefaultBitratePriority,
       VideoEncoderConfig::ContentType::kScreen);
   worker_queue_.RunSynchronous([&] {
-    vss_impl->StartPerRtpStream({true});
+    vss_impl->Start();
     const uint32_t kBitrateBps = 100000;
     // Unpause encoder, to allows allocations to be passed through.
     EXPECT_CALL(rtp_video_sender_, GetPayloadBitrateBps())
@@ -716,7 +709,7 @@
   auto vss_impl = CreateVideoSendStreamImpl(
       kDefaultInitialBitrateBps, kDefaultBitratePriority,
       VideoEncoderConfig::ContentType::kRealtimeVideo);
-  worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+  worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
   VideoStream qvga_stream;
   qvga_stream.width = 320;
   qvga_stream.height = 180;
@@ -849,7 +842,7 @@
   int min_transmit_bitrate_bps = 30000;
 
   config_.rtp.ssrcs.emplace_back(1);
-  worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+  worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
   // Starts without padding.
   EXPECT_EQ(0, padding_bitrate);
   encoder_queue_->PostTask([&] {
@@ -900,7 +893,7 @@
       VideoEncoderConfig::ContentType::kRealtimeVideo);
   EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get())).Times(0);
   worker_queue_.RunSynchronous([&] {
-    vss_impl->StartPerRtpStream({true});
+    vss_impl->Start();
     const uint32_t kBitrateBps = 100000;
     EXPECT_CALL(rtp_video_sender_, GetPayloadBitrateBps())
         .Times(1)
@@ -948,7 +941,7 @@
             ? VideoEncoderConfig::ContentType::kScreen
             : VideoEncoderConfig::ContentType::kRealtimeVideo);
 
-    worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+    worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
 
     // Svc
     VideoStream stream;