Move more calls to webrtc::field_trial::FindFullName into ctor

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webrtc/video/video_send_stream.h"
@@ skipping 274 matching lines @@
 
   pad_up_to_bitrate_bps =
       std::max(pad_up_to_bitrate_bps, min_transmit_bitrate_bps);
 
   return pad_up_to_bitrate_bps;
 }
 
 uint32_t CalculateOverheadRateBps(int packets_per_second,
                                   size_t overhead_bytes_per_packet,
                                   uint32_t max_overhead_bps) {
-  if (webrtc::field_trial::FindFullName("WebRTC-SendSideBwe-WithOverhead") !=
-      "Enabled")
-    return 0;
   uint32_t overhead_bps =
       static_cast<uint32_t>(8 * overhead_bytes_per_packet * packets_per_second);
   return std::min(overhead_bps, max_overhead_bps);
 }
 
 int CalculatePacketRate(uint32_t bitrate_bps, size_t packet_size_bytes) {
   size_t packet_size_bits = 8 * packet_size_bytes;
   // Ceil for int value of bitrate_bps / packet_size_bits.
   return static_cast<int>((bitrate_bps + packet_size_bits - 1) /
                           packet_size_bits);
@@ skipping 83 matching lines @@
       const RTPFragmentationHeader* fragmentation) override;
 
   // Implements VideoBitrateAllocationObserver.
   void OnBitrateAllocationUpdated(const BitrateAllocation& allocation) override;
 
   void ConfigureProtection();
   void ConfigureSsrcs();
   void SignalEncoderTimedOut();
   void SignalEncoderActive();
 
+  const bool send_side_bwe_with_overhead_;
+
   SendStatisticsProxy* const stats_proxy_;
   const VideoSendStream::Config* const config_;
   std::map<uint32_t, RtpState> suspended_ssrcs_;
 
   ProcessThread* module_process_thread_;
   rtc::ThreadChecker module_process_thread_checker_;
   rtc::TaskQueue* const worker_queue_;
 
   rtc::CriticalSection encoder_activity_crit_sect_;
   CheckEncoderActivityTask* check_encoder_activity_task_
@@ skipping 340 matching lines @@
     CongestionController* congestion_controller,
     PacketRouter* packet_router,
     BitrateAllocator* bitrate_allocator,
     SendDelayStats* send_delay_stats,
     VieRemb* remb,
     ViEEncoder* vie_encoder,
     RtcEventLog* event_log,
     const VideoSendStream::Config* config,
     int initial_encoder_max_bitrate,
     std::map<uint32_t, RtpState> suspended_ssrcs)
-    : stats_proxy_(stats_proxy),
+    : send_side_bwe_with_overhead_(webrtc::field_trial::FindFullName(
+            "WebRTC-SendSideBwe-WithOverhead") == "Enabled"),
+      stats_proxy_(stats_proxy),
       config_(config),
       suspended_ssrcs_(std::move(suspended_ssrcs)),
       module_process_thread_(nullptr),
       worker_queue_(worker_queue),
       check_encoder_activity_task_(nullptr),
       call_stats_(call_stats),
       congestion_controller_(congestion_controller),
       packet_router_(packet_router),
       bitrate_allocator_(bitrate_allocator),
       remb_(remb),
@@ skipping 447 matching lines @@
 uint32_t VideoSendStreamImpl::OnBitrateUpdated(uint32_t bitrate_bps,
                                                uint8_t fraction_loss,
                                                int64_t rtt,
                                                int64_t probing_interval_ms) {
   RTC_DCHECK_RUN_ON(worker_queue_);
   RTC_DCHECK(payload_router_.IsActive())
       << "VideoSendStream::Start has not been called.";
 
   // Substract overhead from bitrate.
   rtc::CritScope lock(&overhead_bytes_per_packet_crit_);
-  uint32_t payload_bitrate_bps =
-      bitrate_bps -
-      CalculateOverheadRateBps(
-          CalculatePacketRate(bitrate_bps,
-                              config_->rtp.max_packet_size +
-                                  transport_overhead_bytes_per_packet_),
-          overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_,
-          bitrate_bps);
+  uint32_t payload_bitrate_bps = bitrate_bps;
+  if (send_side_bwe_with_overhead_) {
+    payload_bitrate_bps -= CalculateOverheadRateBps(
+        CalculatePacketRate(bitrate_bps,
+                            config_->rtp.max_packet_size +
+                                transport_overhead_bytes_per_packet_),
+        overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_,
+        bitrate_bps);
+  }
 
   // Get the encoder target rate. It is the estimated network rate -
   // protection overhead.
   encoder_target_rate_bps_ = protection_bitrate_calculator_.SetTargetRates(
       payload_bitrate_bps, stats_proxy_->GetSendFrameRate(), fraction_loss,
       rtt);
 
-  uint32_t encoder_overhead_rate_bps = CalculateOverheadRateBps(
-      CalculatePacketRate(encoder_target_rate_bps_,
-                          config_->rtp.max_packet_size +
-                              transport_overhead_bytes_per_packet_ -
-                              overhead_bytes_per_packet_),
-      overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_,
-      bitrate_bps - encoder_target_rate_bps_);
+  uint32_t encoder_overhead_rate_bps =
+      send_side_bwe_with_overhead_
+          ? CalculateOverheadRateBps(
+                CalculatePacketRate(encoder_target_rate_bps_,
+                                    config_->rtp.max_packet_size +
+                                        transport_overhead_bytes_per_packet_ -
+                                        overhead_bytes_per_packet_),
+                overhead_bytes_per_packet_ +
+                    transport_overhead_bytes_per_packet_,
+                bitrate_bps - encoder_target_rate_bps_)
+          : 0;
 
   // When the field trial "WebRTC-SendSideBwe-WithOverhead" is enabled
   // protection_bitrate includes overhead.
   uint32_t protection_bitrate =
       bitrate_bps - (encoder_target_rate_bps_ + encoder_overhead_rate_bps);
 
   encoder_target_rate_bps_ =
       std::min(encoder_max_bitrate_bps_, encoder_target_rate_bps_);
   vie_encoder_->OnBitrateUpdated(encoder_target_rate_bps_, fraction_loss, rtt);
   stats_proxy_->OnSetEncoderTargetRate(encoder_target_rate_bps_);
@@ skipping 67 matching lines @@
       std::min(config_->rtp.max_packet_size,
                kPathMTU - transport_overhead_bytes_per_packet_);
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->SetMaxRtpPacketSize(rtp_packet_size);
   }
 }
 
 }  // namespace internal
 }  // namespace webrtc