Replace DataSize and DataRate factories with newer versions

This is search and replace change:
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataSize::Bytes<\(.*\)>()/DataSize::Bytes(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataSize::bytes/DataSize::Bytes/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataRate::BitsPerSec<\(.*\)>()/DataRate::BitsPerSec(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataRate::BytesPerSec<\(.*\)>()/DataRate::BytesPerSec(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataRate::KilobitsPerSec<\(.*\)>()/DataRate::KilobitsPerSec(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataRate::bps/DataRate::BitsPerSec/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataRate::kbps/DataRate::KilobitsPerSec/g"
git cl format

Bug: webrtc:9709
Change-Id: I65aaca69474ba038c1fe2dd8dc30d3f8e7b94c29
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168647
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30545}

5 files changed, 39 insertions, 33 deletions

diff --git a/media/engine/simulcast.cc b/media/engine/simulcast.cc
index 94609ff6ea..5fc6a99d78 100644
--- a/media/engine/simulcast.cc
+++ b/media/engine/simulcast.cc
@@ -45,16 +45,16 @@ constexpr char kUseLegacySimulcastLayerLimitFieldTrial[] =
 // Limits for legacy conference screensharing mode. Currently used for the
 // lower of the two simulcast streams.
 constexpr webrtc::DataRate kScreenshareDefaultTl0Bitrate =
-    webrtc::DataRate::kbps(200);
+    webrtc::DataRate::KilobitsPerSec(200);
 constexpr webrtc::DataRate kScreenshareDefaultTl1Bitrate =
-    webrtc::DataRate::kbps(1000);
+    webrtc::DataRate::KilobitsPerSec(1000);
 
 // Min/max bitrate for the higher one of the two simulcast stream used for
 // screen content.
 constexpr webrtc::DataRate kScreenshareHighStreamMinBitrate =
-    webrtc::DataRate::kbps(600);
+    webrtc::DataRate::KilobitsPerSec(600);
 constexpr webrtc::DataRate kScreenshareHighStreamMaxBitrate =
-    webrtc::DataRate::kbps(1250);
+    webrtc::DataRate::KilobitsPerSec(1250);
 
 }  // namespace
 
@@ -78,24 +78,28 @@ struct SimulcastFormat {
 // These tables describe from which resolution we can use how many
 // simulcast layers at what bitrates (maximum, target, and minimum).
 // Important!! Keep this table from high resolution to low resolution.
-// clang-format off
 constexpr const SimulcastFormat kSimulcastFormats[] = {
-  {1920, 1080, 3, webrtc::DataRate::kbps(5000), webrtc::DataRate::kbps(4000),
-    webrtc::DataRate::kbps(800)},
-  {1280, 720, 3, webrtc::DataRate::kbps(2500), webrtc::DataRate::kbps(2500),
-    webrtc::DataRate::kbps(600)},
-  {960, 540, 3, webrtc::DataRate::kbps(1200), webrtc::DataRate::kbps(1200),
-    webrtc::DataRate::kbps(350)},
-  {640, 360, 2, webrtc::DataRate::kbps(700), webrtc::DataRate::kbps(500),
-    webrtc::DataRate::kbps(150)},
-  {480, 270, 2, webrtc::DataRate::kbps(450), webrtc::DataRate::kbps(350),
-    webrtc::DataRate::kbps(150)},
-  {320, 180, 1, webrtc::DataRate::kbps(200), webrtc::DataRate::kbps(150),
-    webrtc::DataRate::kbps(30)},
-  {0, 0, 1, webrtc::DataRate::kbps(200), webrtc::DataRate::kbps(150),
-    webrtc::DataRate::kbps(30)}
-};
-// clang-format on
+    {1920, 1080, 3, webrtc::DataRate::KilobitsPerSec(5000),
+     webrtc::DataRate::KilobitsPerSec(4000),
+     webrtc::DataRate::KilobitsPerSec(800)},
+    {1280, 720, 3, webrtc::DataRate::KilobitsPerSec(2500),
+     webrtc::DataRate::KilobitsPerSec(2500),
+     webrtc::DataRate::KilobitsPerSec(600)},
+    {960, 540, 3, webrtc::DataRate::KilobitsPerSec(1200),
+     webrtc::DataRate::KilobitsPerSec(1200),
+     webrtc::DataRate::KilobitsPerSec(350)},
+    {640, 360, 2, webrtc::DataRate::KilobitsPerSec(700),
+     webrtc::DataRate::KilobitsPerSec(500),
+     webrtc::DataRate::KilobitsPerSec(150)},
+    {480, 270, 2, webrtc::DataRate::KilobitsPerSec(450),
+     webrtc::DataRate::KilobitsPerSec(350),
+     webrtc::DataRate::KilobitsPerSec(150)},
+    {320, 180, 1, webrtc::DataRate::KilobitsPerSec(200),
+     webrtc::DataRate::KilobitsPerSec(150),
+     webrtc::DataRate::KilobitsPerSec(30)},
+    {0, 0, 1, webrtc::DataRate::KilobitsPerSec(200),
+     webrtc::DataRate::KilobitsPerSec(150),
+     webrtc::DataRate::KilobitsPerSec(30)}};
 
 const int kMaxScreenshareSimulcastLayers = 2;
 
@@ -222,7 +226,7 @@ webrtc::DataRate GetTotalMaxBitrate(
     total_max_bitrate_bps += layers[s].target_bitrate_bps;
   }
   total_max_bitrate_bps += layers.back().max_bitrate_bps;
-  return webrtc::DataRate::bps(total_max_bitrate_bps);
+  return webrtc::DataRate::BitsPerSec(total_max_bitrate_bps);
 }
 
 size_t LimitSimulcastLayerCount(int width,
diff --git a/media/engine/simulcast_encoder_adapter.cc b/media/engine/simulcast_encoder_adapter.cc
index 1ec4a56387..03768de1cd 100644
--- a/media/engine/simulcast_encoder_adapter.cc
+++ b/media/engine/simulcast_encoder_adapter.cc
@@ -508,14 +508,14 @@ void SimulcastEncoderAdapter::SetRates(
     // Assign link allocation proportionally to spatial layer allocation.
     if (parameters.bandwidth_allocation != DataRate::Zero()) {
       stream_parameters.bandwidth_allocation =
-          DataRate::bps((parameters.bandwidth_allocation.bps() *
-                         stream_parameters.bitrate.get_sum_bps()) /
-                        parameters.bitrate.get_sum_bps());
+          DataRate::BitsPerSec((parameters.bandwidth_allocation.bps() *
+                                stream_parameters.bitrate.get_sum_bps()) /
+                               parameters.bitrate.get_sum_bps());
       // Make sure we don't allocate bandwidth lower than target bitrate.
       if (stream_parameters.bandwidth_allocation.bps() <
           stream_parameters.bitrate.get_sum_bps()) {
         stream_parameters.bandwidth_allocation =
-            DataRate::bps(stream_parameters.bitrate.get_sum_bps());
+            DataRate::BitsPerSec(stream_parameters.bitrate.get_sum_bps());
       }
     }
 
diff --git a/media/engine/simulcast_encoder_adapter_unittest.cc b/media/engine/simulcast_encoder_adapter_unittest.cc
index bbd6ade822..04ea92e2d8 100644
--- a/media/engine/simulcast_encoder_adapter_unittest.cc
+++ b/media/engine/simulcast_encoder_adapter_unittest.cc
@@ -1275,10 +1275,11 @@ TEST_F(TestSimulcastEncoderAdapterFake, SetRateDistributesBandwithAllocation) {
       kVideoCodecVP8);
   codec_.numberOfSimulcastStreams = 3;
   const DataRate target_bitrate =
-      DataRate::kbps(codec_.simulcastStream[0].targetBitrate +
-                     codec_.simulcastStream[1].targetBitrate +
-                     codec_.simulcastStream[2].minBitrate);
-  const DataRate bandwidth_allocation = target_bitrate + DataRate::kbps(600);
+      DataRate::KilobitsPerSec(codec_.simulcastStream[0].targetBitrate +
+                               codec_.simulcastStream[1].targetBitrate +
+                               codec_.simulcastStream[2].minBitrate);
+  const DataRate bandwidth_allocation =
+      target_bitrate + DataRate::KilobitsPerSec(600);
 
   rate_allocator_.reset(new SimulcastRateAllocator(codec_));
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, kSettings));
@@ -1357,7 +1358,8 @@ TEST_F(TestSimulcastEncoderAdapterFake, SupportsFallback) {
   // Make sure we have bitrate for all layers.
   DataRate max_bitrate = DataRate::Zero();
   for (int i = 0; i < 3; ++i) {
-    max_bitrate += DataRate::kbps(codec_.simulcastStream[i].maxBitrate);
+    max_bitrate +=
+        DataRate::KilobitsPerSec(codec_.simulcastStream[i].maxBitrate);
   }
   const auto rate_settings = VideoEncoder::RateControlParameters(
       rate_allocator_->Allocate(
diff --git a/media/engine/simulcast_unittest.cc b/media/engine/simulcast_unittest.cc
index e5c4c89a42..0ce388a9ee 100644
--- a/media/engine/simulcast_unittest.cc
+++ b/media/engine/simulcast_unittest.cc
@@ -63,7 +63,7 @@ TEST(SimulcastTest, BandwidthAboveTotalMaxBitrateGivenToHighestStream) {
   streams[1].target_bitrate_bps = 200000;
   streams[2].max_bitrate_bps = 400000;
 
-  const webrtc::DataRate one_bps = webrtc::DataRate::bps(1);
+  const webrtc::DataRate one_bps = webrtc::DataRate::BitsPerSec(1);
 
   // No bitrate above the total max to give to the highest stream.
   const webrtc::DataRate max_total_bitrate =
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index e1ec17301d..1b8e1374aa 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -3349,7 +3349,7 @@ EncoderStreamFactory::CreateSimulcastOrConfereceModeScreenshareStreams(
     // No application-configured maximum for the largest layer.
     // If there is bitrate leftover, give it to the largest layer.
     BoostMaxSimulcastLayer(
-        webrtc::DataRate::bps(encoder_config.max_bitrate_bps), &layers);
+        webrtc::DataRate::BitsPerSec(encoder_config.max_bitrate_bps), &layers);
   }
   return layers;
 }