Update BitBuffer methods to style guide
Specifically, use reference instead of pointer for out parameter
and place the out parameter last, for the following methods
ReadUInt8
ReadUInt16
ReadUInt32
ReadBits
PeekBits
ReadNonSymmetric
ReadSignedExponentialGolomb
ReadExponentialGolomb
Bug: webrtc:11933
Change-Id: I3f1efe3e29155985277b0cd18700ddea25fe7914
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/218504
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34037}
diff --git a/rtc_base/bit_buffer_unittest.cc b/rtc_base/bit_buffer_unittest.cc
index 86c4f7f..e6bb427 100644
--- a/rtc_base/bit_buffer_unittest.cc
+++ b/rtc_base/bit_buffer_unittest.cc
@@ -49,13 +49,13 @@
uint16_t val16;
uint32_t val32;
BitBuffer buffer(bytes, 8);
- EXPECT_TRUE(buffer.ReadUInt8(&val8));
+ EXPECT_TRUE(buffer.ReadUInt8(val8));
EXPECT_EQ(0x0Au, val8);
- EXPECT_TRUE(buffer.ReadUInt8(&val8));
+ EXPECT_TRUE(buffer.ReadUInt8(val8));
EXPECT_EQ(0xBCu, val8);
- EXPECT_TRUE(buffer.ReadUInt16(&val16));
+ EXPECT_TRUE(buffer.ReadUInt16(val16));
EXPECT_EQ(0xDEF1u, val16);
- EXPECT_TRUE(buffer.ReadUInt32(&val32));
+ EXPECT_TRUE(buffer.ReadUInt32(val32));
EXPECT_EQ(0x23456789u, val32);
}
@@ -68,13 +68,13 @@
BitBuffer buffer(bytes, 9);
EXPECT_TRUE(buffer.ConsumeBits(4));
- EXPECT_TRUE(buffer.ReadUInt8(&val8));
+ EXPECT_TRUE(buffer.ReadUInt8(val8));
EXPECT_EQ(0xABu, val8);
- EXPECT_TRUE(buffer.ReadUInt8(&val8));
+ EXPECT_TRUE(buffer.ReadUInt8(val8));
EXPECT_EQ(0xCDu, val8);
- EXPECT_TRUE(buffer.ReadUInt16(&val16));
+ EXPECT_TRUE(buffer.ReadUInt16(val16));
EXPECT_EQ(0xEF12u, val16);
- EXPECT_TRUE(buffer.ReadUInt32(&val32));
+ EXPECT_TRUE(buffer.ReadUInt32(val32));
EXPECT_EQ(0x34567890u, val32);
}
@@ -102,15 +102,15 @@
uint32_t val32;
BitBuffer buffer(bytes, 8);
EXPECT_TRUE(buffer.ConsumeBits(3));
- EXPECT_TRUE(buffer.ReadUInt8(&val8));
+ EXPECT_TRUE(buffer.ReadUInt8(val8));
EXPECT_EQ(0xFEu, val8);
- EXPECT_TRUE(buffer.ReadUInt16(&val16));
+ EXPECT_TRUE(buffer.ReadUInt16(val16));
EXPECT_EQ(0xDCBAu, val16);
- EXPECT_TRUE(buffer.ReadUInt32(&val32));
+ EXPECT_TRUE(buffer.ReadUInt32(val32));
EXPECT_EQ(0x98765432u, val32);
// 5 bits left unread. Not enough to read a uint8_t.
EXPECT_EQ(5u, buffer.RemainingBitCount());
- EXPECT_FALSE(buffer.ReadUInt8(&val8));
+ EXPECT_FALSE(buffer.ReadUInt8(val8));
}
TEST(BitBufferTest, ReadBits) {
@@ -120,26 +120,26 @@
const uint8_t bytes[] = {0x4D, 0x32};
uint32_t val;
BitBuffer buffer(bytes, 2);
- EXPECT_TRUE(buffer.ReadBits(&val, 3));
+ EXPECT_TRUE(buffer.ReadBits(3, val));
// 0b010
EXPECT_EQ(0x2u, val);
- EXPECT_TRUE(buffer.ReadBits(&val, 2));
+ EXPECT_TRUE(buffer.ReadBits(2, val));
// 0b01
EXPECT_EQ(0x1u, val);
- EXPECT_TRUE(buffer.ReadBits(&val, 7));
+ EXPECT_TRUE(buffer.ReadBits(7, val));
// 0b1010011
EXPECT_EQ(0x53u, val);
- EXPECT_TRUE(buffer.ReadBits(&val, 2));
+ EXPECT_TRUE(buffer.ReadBits(2, val));
// 0b00
EXPECT_EQ(0x0u, val);
- EXPECT_TRUE(buffer.ReadBits(&val, 1));
+ EXPECT_TRUE(buffer.ReadBits(1, val));
// 0b1
EXPECT_EQ(0x1u, val);
- EXPECT_TRUE(buffer.ReadBits(&val, 1));
+ EXPECT_TRUE(buffer.ReadBits(1, val));
// 0b0
EXPECT_EQ(0x0u, val);
- EXPECT_FALSE(buffer.ReadBits(&val, 1));
+ EXPECT_FALSE(buffer.ReadBits(1, val));
}
TEST(BitBufferTest, ReadBits64) {
@@ -149,29 +149,29 @@
uint64_t val;
// Peek and read first 33 bits.
- EXPECT_TRUE(buffer.PeekBits(&val, 33));
+ EXPECT_TRUE(buffer.PeekBits(33, val));
EXPECT_EQ(0x4D32AB5400FFFE01ull >> (64 - 33), val);
val = 0;
- EXPECT_TRUE(buffer.ReadBits(&val, 33));
+ EXPECT_TRUE(buffer.ReadBits(33, val));
EXPECT_EQ(0x4D32AB5400FFFE01ull >> (64 - 33), val);
// Peek and read next 31 bits.
constexpr uint64_t kMask31Bits = (1ull << 32) - 1;
- EXPECT_TRUE(buffer.PeekBits(&val, 31));
+ EXPECT_TRUE(buffer.PeekBits(31, val));
EXPECT_EQ(0x4D32AB5400FFFE01ull & kMask31Bits, val);
val = 0;
- EXPECT_TRUE(buffer.ReadBits(&val, 31));
+ EXPECT_TRUE(buffer.ReadBits(31, val));
EXPECT_EQ(0x4D32AB5400FFFE01ull & kMask31Bits, val);
// Peek and read remaining 64 bits.
- EXPECT_TRUE(buffer.PeekBits(&val, 64));
+ EXPECT_TRUE(buffer.PeekBits(64, val));
EXPECT_EQ(0xABCDEF0123456789ull, val);
val = 0;
- EXPECT_TRUE(buffer.ReadBits(&val, 64));
+ EXPECT_TRUE(buffer.ReadBits(64, val));
EXPECT_EQ(0xABCDEF0123456789ull, val);
// Nothing more to read.
- EXPECT_FALSE(buffer.ReadBits(&val, 1));
+ EXPECT_FALSE(buffer.ReadBits(1, val));
}
TEST(BitBufferDeathTest, SetOffsetValues) {
@@ -219,10 +219,10 @@
uint32_t values[4];
ASSERT_EQ(reader.RemainingBitCount(), 16u);
- EXPECT_TRUE(reader.ReadNonSymmetric(&values[0], /*num_values=*/1 << 4));
- EXPECT_TRUE(reader.ReadNonSymmetric(&values[1], /*num_values=*/1 << 4));
- EXPECT_TRUE(reader.ReadNonSymmetric(&values[2], /*num_values=*/1 << 4));
- EXPECT_TRUE(reader.ReadNonSymmetric(&values[3], /*num_values=*/1 << 4));
+ EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/1 << 4, values[0]));
+ EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/1 << 4, values[1]));
+ EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/1 << 4, values[2]));
+ EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/1 << 4, values[3]));
ASSERT_EQ(reader.RemainingBitCount(), 0u);
EXPECT_THAT(values, ElementsAre(0xf, 0x3, 0xa, 0x0));
@@ -276,12 +276,12 @@
rtc::BitBuffer reader(bytes, 2);
uint32_t values[6];
- EXPECT_TRUE(reader.ReadNonSymmetric(&values[0], /*num_values=*/6));
- EXPECT_TRUE(reader.ReadNonSymmetric(&values[1], /*num_values=*/6));
- EXPECT_TRUE(reader.ReadNonSymmetric(&values[2], /*num_values=*/6));
- EXPECT_TRUE(reader.ReadNonSymmetric(&values[3], /*num_values=*/6));
- EXPECT_TRUE(reader.ReadNonSymmetric(&values[4], /*num_values=*/6));
- EXPECT_TRUE(reader.ReadNonSymmetric(&values[5], /*num_values=*/6));
+ EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[0]));
+ EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[1]));
+ EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[2]));
+ EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[3]));
+ EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[4]));
+ EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[5]));
EXPECT_THAT(values, ElementsAre(0, 1, 2, 3, 4, 5));
}
@@ -292,7 +292,7 @@
uint32_t value = 0xFFFFFFFF;
ASSERT_EQ(reader.RemainingBitCount(), 16u);
- EXPECT_TRUE(reader.ReadNonSymmetric(&value, /*num_values=*/1));
+ EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/1, value));
EXPECT_EQ(value, 0u);
EXPECT_EQ(reader.RemainingBitCount(), 16u);
@@ -334,7 +334,7 @@
byteBuffer.WriteUInt64(encoded_val);
uint32_t decoded_val;
EXPECT_TRUE(buffer.Seek(0, 0));
- EXPECT_TRUE(buffer.ReadExponentialGolomb(&decoded_val));
+ EXPECT_TRUE(buffer.ReadExponentialGolomb(decoded_val));
EXPECT_EQ(i, decoded_val);
}
}
@@ -351,7 +351,7 @@
for (size_t i = 0; i < sizeof(golomb_bits); ++i) {
BitBuffer buffer(&golomb_bits[i], 1);
int32_t decoded_val;
- ASSERT_TRUE(buffer.ReadSignedExponentialGolomb(&decoded_val));
+ ASSERT_TRUE(buffer.ReadSignedExponentialGolomb(decoded_val));
EXPECT_EQ(expected[i], decoded_val)
<< "Mismatch in expected/decoded value for golomb_bits[" << i
<< "]: " << static_cast<int>(golomb_bits[i]);
@@ -364,13 +364,13 @@
// If it didn't, the above buffer would be valid at 3 bytes.
BitBuffer buffer(bytes, 1);
uint32_t decoded_val;
- EXPECT_FALSE(buffer.ReadExponentialGolomb(&decoded_val));
+ EXPECT_FALSE(buffer.ReadExponentialGolomb(decoded_val));
BitBuffer longer_buffer(bytes, 2);
- EXPECT_FALSE(longer_buffer.ReadExponentialGolomb(&decoded_val));
+ EXPECT_FALSE(longer_buffer.ReadExponentialGolomb(decoded_val));
BitBuffer longest_buffer(bytes, 3);
- EXPECT_TRUE(longest_buffer.ReadExponentialGolomb(&decoded_val));
+ EXPECT_TRUE(longest_buffer.ReadExponentialGolomb(decoded_val));
// Golomb should have read 9 bits, so 0x01FF, and since it is golomb, the
// result is 0x01FF - 1 = 0x01FE.
EXPECT_EQ(0x01FEu, decoded_val);
@@ -392,20 +392,20 @@
EXPECT_TRUE(buffer.Seek(0, 0));
uint32_t val;
- EXPECT_TRUE(buffer.ReadBits(&val, 3));
+ EXPECT_TRUE(buffer.ReadBits(3, val));
EXPECT_EQ(0x2u, val);
- EXPECT_TRUE(buffer.ReadBits(&val, 2));
+ EXPECT_TRUE(buffer.ReadBits(2, val));
EXPECT_EQ(0x1u, val);
- EXPECT_TRUE(buffer.ReadBits(&val, 7));
+ EXPECT_TRUE(buffer.ReadBits(7, val));
EXPECT_EQ(0x53u, val);
- EXPECT_TRUE(buffer.ReadBits(&val, 2));
+ EXPECT_TRUE(buffer.ReadBits(2, val));
EXPECT_EQ(0x0u, val);
- EXPECT_TRUE(buffer.ReadBits(&val, 1));
+ EXPECT_TRUE(buffer.ReadBits(1, val));
EXPECT_EQ(0x1u, val);
- EXPECT_TRUE(buffer.ReadBits(&val, 17));
+ EXPECT_TRUE(buffer.ReadBits(17, val));
EXPECT_EQ(0x1ABCDu, val);
// And there should be nothing left.
- EXPECT_FALSE(buffer.ReadBits(&val, 1));
+ EXPECT_FALSE(buffer.ReadBits(1, val));
}
TEST(BitBufferWriterTest, SymmetricBytesMisaligned) {
@@ -422,11 +422,11 @@
uint8_t val8;
uint16_t val16;
uint32_t val32;
- EXPECT_TRUE(buffer.ReadUInt8(&val8));
+ EXPECT_TRUE(buffer.ReadUInt8(val8));
EXPECT_EQ(0x12u, val8);
- EXPECT_TRUE(buffer.ReadUInt16(&val16));
+ EXPECT_TRUE(buffer.ReadUInt16(val16));
EXPECT_EQ(0x3456u, val16);
- EXPECT_TRUE(buffer.ReadUInt32(&val32));
+ EXPECT_TRUE(buffer.ReadUInt32(val32));
EXPECT_EQ(0x789ABCDEu, val32);
}
@@ -440,7 +440,7 @@
buffer.Seek(0, 0);
for (size_t i = 0; i < arraysize(test_string); ++i) {
uint32_t val;
- EXPECT_TRUE(buffer.ReadExponentialGolomb(&val));
+ EXPECT_TRUE(buffer.ReadExponentialGolomb(val));
EXPECT_LE(val, std::numeric_limits<uint8_t>::max());
EXPECT_EQ(test_string[i], static_cast<char>(val));
}