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 271 matching lines @@
   } else if (pad_to_min_bitrate) {
     pad_up_to_bitrate_bps = streams[0].min_bitrate_bps;
   }
 
   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);
 }
 
 }  // namespace
 
 namespace internal {
@@ skipping 78 matching lines @@
       const RTPFragmentationHeader* fragmentation) override;
 
   // Implements VideoBitrateAllocationObserver.
   void OnBitrateAllocationUpdated(const BitrateAllocation& allocation) override;
 
   void ConfigureProtection();
   void ConfigureSsrcs();
   void SignalEncoderTimedOut();
   void SignalEncoderActive();
 
+  uint32_t CalculateOverheadRateBps(int packets_per_second,
+                                    size_t overhead_bytes_per_packet,

[minyue-webrtc, 2017/01/31 11:48:06]

Feels better if we keep it outside but add send_side_bwe_with_overhead as an
arg. Because it is a utility function (given all private vars, it is still
unable to calculate overhead rate)

+                                    uint32_t max_overhead_bps);
+
+  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 199 matching lines @@
 }
 
 void VideoSendStreamImpl::SignalEncoderActive() {
   RTC_DCHECK_RUN_ON(worker_queue_);
   LOG(LS_INFO) << "SignalEncoderActive, Encoder is active.";
   bitrate_allocator_->AddObserver(
       this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
       max_padding_bitrate_, !config_->suspend_below_min_bitrate);
 }
 
+uint32_t VideoSendStreamImpl::CalculateOverheadRateBps(
+    int packets_per_second,
+    size_t overhead_bytes_per_packet,
+    uint32_t max_overhead_bps) {
+  if (!send_side_bwe_with_overhead_)
+    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);
+}
+
 void VideoSendStreamImpl::OnEncoderConfigurationChanged(
     std::vector<VideoStream> streams,
     int min_transmit_bitrate_bps) {
   if (!worker_queue_->IsCurrent()) {
     worker_queue_->PostTask(
         std::unique_ptr<rtc::QueuedTask>(new EncoderReconfiguredTask(
             weak_ptr_, std::move(streams), min_transmit_bitrate_bps)));
     return;
   }
   RTC_DCHECK_GE(config_->rtp.ssrcs.size(), streams.size());
@@ skipping 337 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