diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index b2ae144572..7ae55dcf72 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -359,6 +359,7 @@ void VideoSendStream::ReconfigureVideoEncoder(
   static const int kEncoderMinBitrateKbps = 30;
   RTC_DCHECK(!streams.empty());
   RTC_DCHECK_GE(config_.rtp.ssrcs.size(), streams.size());
+  RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
 
   VideoCodec video_codec;
   memset(&video_codec, 0, sizeof(video_codec));
@@ -486,18 +487,7 @@ void VideoSendStream::ReconfigureVideoEncoder(
   RTC_DCHECK_GT(streams[0].max_framerate, 0);
   video_codec.maxFramerate = streams[0].max_framerate;
 
-  vie_encoder_.SetEncoder(video_codec);
-
-  // Clear stats for disabled layers.
-  for (size_t i = video_codec.numberOfSimulcastStreams;
-       i < config_.rtp.ssrcs.size(); ++i) {
-    stats_proxy_.OnInactiveSsrc(config_.rtp.ssrcs[i]);
-  }
-
-  stats_proxy_.SetContentType(config.content_type);
-
-  RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
-  vie_encoder_.SetMinTransmitBitrate(config.min_transmit_bitrate_bps / 1000);
+  vie_encoder_.SetEncoder(video_codec, config.min_transmit_bitrate_bps);
 }
 
 bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
diff --git a/webrtc/video/vie_encoder.cc b/webrtc/video/vie_encoder.cc
index 1433879f2d..7a453efc10 100644
--- a/webrtc/video/vie_encoder.cc
+++ b/webrtc/video/vie_encoder.cc
@@ -120,7 +120,7 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores,
       bitrate_allocator_(bitrate_allocator),
       time_of_last_frame_activity_ms_(0),
       encoder_config_(),
-      min_transmit_bitrate_kbps_(0),
+      min_transmit_bitrate_bps_(0),
       last_observed_bitrate_bps_(0),
       network_is_transmitting_(true),
       encoder_paused_(false),
@@ -194,7 +194,8 @@ int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
   }
   return 0;
 }
-void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
+void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec,
+                            int min_transmit_bitrate_bps) {
   RTC_DCHECK(send_payload_router_ != NULL);
   // Setting target width and height for VPM.
   RTC_CHECK_EQ(VPM_OK,
@@ -207,6 +208,7 @@ void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
     rtc::CritScope lock(&data_cs_);
     encoder_config_ = video_codec;
     encoder_paused_ = true;
+    min_transmit_bitrate_bps_ = min_transmit_bitrate_bps;
   }
 
   // Add a bitrate observer to the allocator and update the start, max and
@@ -232,6 +234,26 @@ void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
 
   // Restart the media flow
   Restart();
+  if (stats_proxy_) {
+    // Clear stats for disabled layers.
+    for (size_t i = video_codec.numberOfSimulcastStreams; i < ssrcs_.size();
+         ++i) {
+      stats_proxy_->OnInactiveSsrc(ssrcs_[i]);
+    }
+    VideoEncoderConfig::ContentType content_type;
+    switch (video_codec.mode) {
+      case kRealtimeVideo:
+        content_type = VideoEncoderConfig::ContentType::kRealtimeVideo;
+        break;
+      case kScreensharing:
+        content_type = VideoEncoderConfig::ContentType::kScreen;
+        break;
+      default:
+        RTC_NOTREACHED();
+        break;
+    }
+    stats_proxy_->SetContentType(content_type);
+  }
 }
 
 int ViEEncoder::GetPaddingNeededBps() const {
@@ -242,11 +264,11 @@ int ViEEncoder::GetPaddingNeededBps() const {
   {
     rtc::CritScope lock(&data_cs_);
     bool send_padding = encoder_config_.numberOfSimulcastStreams > 1 ||
-                        video_suspended_ || min_transmit_bitrate_kbps_ > 0;
+                        video_suspended_ || min_transmit_bitrate_bps_ > 0;
     if (!send_padding)
       return 0;
     time_of_last_frame_activity_ms = time_of_last_frame_activity_ms_;
-    min_transmit_bitrate_bps = 1000 * min_transmit_bitrate_kbps_;
+    min_transmit_bitrate_bps = min_transmit_bitrate_bps_;
     bitrate_bps = last_observed_bitrate_bps_;
     send_codec = encoder_config_;
   }
@@ -488,12 +510,6 @@ void ViEEncoder::OnReceivedIntraFrameRequest(uint32_t ssrc) {
   RTC_NOTREACHED() << "Should not receive keyframe requests on unknown SSRCs.";
 }
 
-void ViEEncoder::SetMinTransmitBitrate(int min_transmit_bitrate_kbps) {
-  assert(min_transmit_bitrate_kbps >= 0);
-  rtc::CritScope lock(&data_cs_);
-  min_transmit_bitrate_kbps_ = min_transmit_bitrate_kbps;
-}
-
 // Called from ViEBitrateObserver.
 void ViEEncoder::OnNetworkChanged(uint32_t bitrate_bps,
                                   uint8_t fraction_lost,
diff --git a/webrtc/video/vie_encoder.h b/webrtc/video/vie_encoder.h
index 7344951438..319300c5d4 100644
--- a/webrtc/video/vie_encoder.h
+++ b/webrtc/video/vie_encoder.h
@@ -78,7 +78,7 @@ class ViEEncoder : public VideoEncoderRateObserver,
                                   uint8_t pl_type,
                                   bool internal_source);
   int32_t DeRegisterExternalEncoder(uint8_t pl_type);
-  void SetEncoder(const VideoCodec& video_codec);
+  void SetEncoder(const VideoCodec& video_codec, int min_transmit_bitrate_bps);
 
   // Implementing VideoCaptureCallback.
   void DeliverFrame(VideoFrame video_frame) override;
@@ -112,8 +112,6 @@ class ViEEncoder : public VideoEncoderRateObserver,
   virtual void OnReceivedSLI(uint32_t ssrc, uint8_t picture_id);
   virtual void OnReceivedRPSI(uint32_t ssrc, uint64_t picture_id);
 
-  void SetMinTransmitBitrate(int min_transmit_bitrate_kbps);
-
   // Lets the sender suspend video when the rate drops below
   // |threshold_bps|, and turns back on when the rate goes back up above
   // |threshold_bps| + |window_bps|.
@@ -158,7 +156,7 @@ class ViEEncoder : public VideoEncoderRateObserver,
   // padding.
   int64_t time_of_last_frame_activity_ms_ GUARDED_BY(data_cs_);
   VideoCodec encoder_config_ GUARDED_BY(data_cs_);
-  int min_transmit_bitrate_kbps_ GUARDED_BY(data_cs_);
+  int min_transmit_bitrate_bps_ GUARDED_BY(data_cs_);
   uint32_t last_observed_bitrate_bps_ GUARDED_BY(data_cs_);
   bool network_is_transmitting_ GUARDED_BY(data_cs_);
   bool encoder_paused_ GUARDED_BY(data_cs_);