From 6c19decc14b706cff039cf4045bc33d67edc1bb7 Mon Sep 17 00:00:00 2001
From: Sebastian Jansson <srte@webrtc.org>
Date: Fri, 5 Oct 2018 13:23:57 +0200
Subject: [PATCH] Adds Clamping functions for DataRate.

This is quite useful in many places where we need to restrict the range
of a DataRate. It makes it easier to read the intention than with:
value_ = std::max(some_lower_limit, std::min(value_, some_upper_limit));

The naming follows the naming for rtc::SafeClamp.

Bug: webrtc:9709
Change-Id: I08e05197acec325d85babd2a06806a8667f2fcb1
Reviewed-on: https://webrtc-review.googlesource.com/c/104040
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25023}
---
 api/units/data_rate.h           |  7 +++++++
 api/units/data_rate_unittest.cc | 20 ++++++++++++++++++++
 2 files changed, 27 insertions(+)

diff --git a/api/units/data_rate.h b/api/units/data_rate.h
index c2202d6a69..4bb988b658 100644
--- a/api/units/data_rate.h
+++ b/api/units/data_rate.h
@@ -16,6 +16,7 @@
 #endif              // UNIT_TEST
 
 #include <stdint.h>
+#include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ -133,6 +134,12 @@ class DataRate {
     return bits_per_sec_ == data_rate_impl::kPlusInfinityVal;
   }
   constexpr bool IsFinite() const { return !IsInfinite(); }
+  DataRate Clamped(DataRate min_rate, DataRate max_rate) const {
+    return std::max(min_rate, std::min(*this, max_rate));
+  }
+  void Clamp(DataRate min_rate, DataRate max_rate) {
+    *this = Clamped(min_rate, max_rate);
+  }
   DataRate operator-(const DataRate& other) const {
     return DataRate::bps(bps() - other.bps());
   }
diff --git a/api/units/data_rate_unittest.cc b/api/units/data_rate_unittest.cc
index be020909c8..8e5b660594 100644
--- a/api/units/data_rate_unittest.cc
+++ b/api/units/data_rate_unittest.cc
@@ -92,6 +92,26 @@ TEST(DataRateTest, ConvertsToAndFromDouble) {
   EXPECT_TRUE(DataRate::bps(kInfinity).IsInfinite());
   EXPECT_TRUE(DataRate::kbps(kInfinity).IsInfinite());
 }
+TEST(DataRateTest, Clamping) {
+  const DataRate upper = DataRate::kbps(800);
+  const DataRate lower = DataRate::kbps(100);
+  const DataRate under = DataRate::kbps(100);
+  const DataRate inside = DataRate::kbps(500);
+  const DataRate over = DataRate::kbps(1000);
+  EXPECT_EQ(under.Clamped(lower, upper), lower);
+  EXPECT_EQ(inside.Clamped(lower, upper), inside);
+  EXPECT_EQ(over.Clamped(lower, upper), upper);
+
+  DataRate mutable_rate = lower;
+  mutable_rate.Clamp(lower, upper);
+  EXPECT_EQ(mutable_rate, lower);
+  mutable_rate = inside;
+  mutable_rate.Clamp(lower, upper);
+  EXPECT_EQ(mutable_rate, inside);
+  mutable_rate = over;
+  mutable_rate.Clamp(lower, upper);
+  EXPECT_EQ(mutable_rate, upper);
+}
 
 TEST(DataRateTest, MathOperations) {
   const int64_t kValueA = 450;