zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removes uninitialized constructors for units.

Browse Source 
Bug: webrtc:9155
Change-Id: I6e95cf123e7a74b5911cc101571cb04bee152381
Reviewed-on: https://webrtc-review.googlesource.com/73370
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23142}
This commit is contained in:
Sebastian Jansson
2018-05-07 13:51:51 +02:00
committed by Commit Bot
parent d8d02147d9
commit 3b69b196e4
9 changed files with 8 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
modules/congestion_controller/network_control/units/data_rate.cc
View File

@ -19,8 +19,6 @@ std::string ToString(const DataRate& value) {
rtc::SimpleStringBuilder sb(buf);
if (value.IsInfinite()) {
sb << "inf bps";
} else if (!value.IsInitialized()) {
sb << "? bps";
} else {
sb << value.bps() << " bps";
}

11
modules/congestion_controller/network_control/units/data_rate.h
View File

@ -25,7 +25,6 @@
namespace webrtc {
namespace data_rate_impl {
constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
constexpr int64_t kNotInitializedVal = -1;
inline int64_t Microbits(const DataSize& size) {
constexpr int64_t kMaxBeforeConversion =
@ -41,7 +40,7 @@ inline int64_t Microbits(const DataSize& size) {
// second (bps).
class DataRate {
public:
DataRate() : DataRate(data_rate_impl::kNotInitializedVal) {}
DataRate() = delete;
static DataRate Zero() { return DataRate(0); }
static DataRate Infinity() {
return DataRate(data_rate_impl::kPlusInfinityVal);
@ -61,18 +60,12 @@ class DataRate {
return bits_per_sec_;
}
int64_t bps() const { return bits_per_second(); }
int64_t bps_or(int64_t fallback) const {
return IsFinite() ? bits_per_second() : fallback;
}
int64_t kbps() const { return (bps() + 500) / 1000; }
bool IsZero() const { return bits_per_sec_ == 0; }
bool IsInfinite() const {
return bits_per_sec_ == data_rate_impl::kPlusInfinityVal;
}
bool IsInitialized() const {
return bits_per_sec_ != data_rate_impl::kNotInitializedVal;
}
bool IsFinite() const { return IsInitialized() && !IsInfinite(); }
bool IsFinite() const { return !IsInfinite(); }
bool operator==(const DataRate& other) const {
return bits_per_sec_ == other.bits_per_sec_;

2
modules/congestion_controller/network_control/units/data_size.cc
View File

@ -19,8 +19,6 @@ std::string ToString(const DataSize& value) {
rtc::SimpleStringBuilder sb(buf);
if (value.IsInfinite()) {
sb << "inf bytes";
} else if (!value.IsInitialized()) {
sb << "? bytes";
} else {
sb << value.bytes() << " bytes";
}

8
modules/congestion_controller/network_control/units/data_size.h
View File

@ -21,13 +21,12 @@
namespace webrtc {
namespace data_size_impl {
constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
constexpr int64_t kNotInitializedVal = -1;
} // namespace data_size_impl
// DataSize is a class represeting a count of bytes.
class DataSize {
public:
DataSize() : DataSize(data_size_impl::kNotInitializedVal) {}
DataSize() = delete;
static DataSize Zero() { return DataSize(0); }
static DataSize Infinity() {
return DataSize(data_size_impl::kPlusInfinityVal);
@ -43,10 +42,7 @@ class DataSize {
int64_t kilobytes() const { return (bytes() + 500) / 1000; }
bool IsZero() const { return bytes_ == 0; }
bool IsInfinite() const { return bytes_ == data_size_impl::kPlusInfinityVal; }
bool IsInitialized() const {
return bytes_ != data_size_impl::kNotInitializedVal;
}
bool IsFinite() const { return IsInitialized() && !IsInfinite(); }
bool IsFinite() const { return !IsInfinite(); }
DataSize operator-(const DataSize& other) const {
return DataSize::bytes(bytes() - other.bytes());
}

2
modules/congestion_controller/network_control/units/time_delta.cc
View File

@ -21,8 +21,6 @@ std::string ToString(const TimeDelta& value) {
sb << "+inf ms";
} else if (value.IsMinusInfinity()) {
sb << "-inf ms";
} else if (!value.IsInitialized()) {
sb << "? ms";
} else {
sb << value.ms() << " ms";
}

10
modules/congestion_controller/network_control/units/time_delta.h
View File

@ -22,8 +22,6 @@ namespace webrtc {
namespace timedelta_impl {
constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
constexpr int64_t kSignedNotInitializedVal = kMinusInfinityVal + 1;
} // namespace timedelta_impl
// TimeDelta represents the difference between two timestamps. Commonly this can
@ -35,7 +33,7 @@ constexpr int64_t kSignedNotInitializedVal = kMinusInfinityVal + 1;
// microseconds (us).
class TimeDelta {
public:
TimeDelta() : TimeDelta(timedelta_impl::kSignedNotInitializedVal) {}
TimeDelta() = delete;
static TimeDelta Zero() { return TimeDelta(0); }
static TimeDelta PlusInfinity() {
return TimeDelta(timedelta_impl::kPlusInfinityVal);
@ -53,7 +51,6 @@ class TimeDelta {
// Infinities only allowed via use of explicit constants.
RTC_DCHECK(microseconds > std::numeric_limits<int64_t>::min());
RTC_DCHECK(microseconds < std::numeric_limits<int64_t>::max());
RTC_DCHECK(microseconds != timedelta_impl::kSignedNotInitializedVal);
return TimeDelta(microseconds);
}
int64_t seconds() const {
@ -69,10 +66,7 @@ class TimeDelta {
TimeDelta Abs() const { return TimeDelta::us(std::abs(us())); }
bool IsZero() const { return microseconds_ == 0; }
bool IsFinite() const { return IsInitialized() && !IsInfinite(); }
bool IsInitialized() const {
return microseconds_ != timedelta_impl::kSignedNotInitializedVal;
}
bool IsFinite() const { return !IsInfinite(); }
bool IsInfinite() const {
return microseconds_ == timedelta_impl::kPlusInfinityVal ||
microseconds_ == timedelta_impl::kMinusInfinityVal;

4
modules/congestion_controller/network_control/units/timestamp.cc
View File

@ -16,8 +16,6 @@ namespace webrtc {
double Timestamp::SecondsAsDouble() const {
if (IsInfinite()) {
return std::numeric_limits<double>::infinity();
} else if (!IsInitialized()) {
return std::numeric_limits<double>::signaling_NaN();
} else {
return us() * 1e-6;
}
@ -28,8 +26,6 @@ std::string ToString(const Timestamp& value) {
rtc::SimpleStringBuilder sb(buf);
if (value.IsInfinite()) {
sb << "inf ms";
} else if (!value.IsInitialized()) {
sb << "? ms";
} else {
sb << value.ms() << " ms";
}

9
modules/congestion_controller/network_control/units/timestamp.h
View File

@ -22,8 +22,6 @@ namespace webrtc {
namespace timestamp_impl {
constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
constexpr int64_t kSignedNotInitializedVal = kMinusInfinityVal + 1;
constexpr int64_t kNotInitializedVal = -1;
} // namespace timestamp_impl
// Timestamp represents the time that has passed since some unspecified epoch.
@ -32,7 +30,7 @@ constexpr int64_t kNotInitializedVal = -1;
// difference of two Timestamps results in a TimeDelta.
class Timestamp {
public:
Timestamp() : Timestamp(timestamp_impl::kNotInitializedVal) {}
Timestamp() = delete;
static Timestamp Infinity() {
return Timestamp(timestamp_impl::kPlusInfinityVal);
}
@ -56,10 +54,7 @@ class Timestamp {
bool IsInfinite() const {
return microseconds_ == timestamp_impl::kPlusInfinityVal;
}
bool IsInitialized() const {
return microseconds_ != timestamp_impl::kNotInitializedVal;
}
bool IsFinite() const { return IsInitialized() && !IsInfinite(); }
bool IsFinite() const { return !IsInfinite(); }
TimeDelta operator-(const Timestamp& other) const {
return TimeDelta::us(us() - other.us());
}

1
modules/congestion_controller/network_control/units/timestamp_unittest.cc
View File

@ -37,7 +37,6 @@ TEST(TimestampTest, IdentityChecks) {
EXPECT_TRUE(Timestamp::Infinity().IsInfinite());
EXPECT_FALSE(Timestamp::ms(kValue).IsInfinite());
EXPECT_FALSE(Timestamp().IsFinite());
EXPECT_FALSE(Timestamp::Infinity().IsFinite());
EXPECT_TRUE(Timestamp::ms(kValue).IsFinite());
}