Use suffixed {uint,int}{8,16,32,64}_t types.
Removes the use of uint8, etc. in favor of uint8_t.
BUG=webrtc:5024
R=henrik.lundin@webrtc.org, henrikg@webrtc.org, perkj@webrtc.org, solenberg@webrtc.org, stefan@webrtc.org, tina.legrand@webrtc.org
Review URL: https://codereview.webrtc.org/1362503003 .
Cr-Commit-Position: refs/heads/master@{#10196}
diff --git a/webrtc/base/asyncinvoker.cc b/webrtc/base/asyncinvoker.cc
index 563ccb7..8285d55 100644
--- a/webrtc/base/asyncinvoker.cc
+++ b/webrtc/base/asyncinvoker.cc
@@ -36,7 +36,7 @@
closure->Execute();
}
-void AsyncInvoker::Flush(Thread* thread, uint32 id /*= MQID_ANY*/) {
+void AsyncInvoker::Flush(Thread* thread, uint32_t id /*= MQID_ANY*/) {
if (destroying_) return;
// Run this on |thread| to reduce the number of context switches.
@@ -57,7 +57,7 @@
void AsyncInvoker::DoInvoke(Thread* thread,
const scoped_refptr<AsyncClosure>& closure,
- uint32 id) {
+ uint32_t id) {
if (destroying_) {
LOG(LS_WARNING) << "Tried to invoke while destroying the invoker.";
return;
@@ -67,8 +67,8 @@
void AsyncInvoker::DoInvokeDelayed(Thread* thread,
const scoped_refptr<AsyncClosure>& closure,
- uint32 delay_ms,
- uint32 id) {
+ uint32_t delay_ms,
+ uint32_t id) {
if (destroying_) {
LOG(LS_WARNING) << "Tried to invoke while destroying the invoker.";
return;
@@ -85,7 +85,7 @@
GuardedAsyncInvoker::~GuardedAsyncInvoker() {
}
-bool GuardedAsyncInvoker::Flush(uint32 id) {
+bool GuardedAsyncInvoker::Flush(uint32_t id) {
rtc::CritScope cs(&crit_);
if (thread_ == nullptr)
return false;
diff --git a/webrtc/base/asyncinvoker.h b/webrtc/base/asyncinvoker.h
index 2d2c65c..a351337 100644
--- a/webrtc/base/asyncinvoker.h
+++ b/webrtc/base/asyncinvoker.h
@@ -74,9 +74,7 @@
// Call |functor| asynchronously on |thread|, with no callback upon
// completion. Returns immediately.
template <class ReturnT, class FunctorT>
- void AsyncInvoke(Thread* thread,
- const FunctorT& functor,
- uint32 id = 0) {
+ void AsyncInvoke(Thread* thread, const FunctorT& functor, uint32_t id = 0) {
scoped_refptr<AsyncClosure> closure(
new RefCountedObject<FireAndForgetAsyncClosure<FunctorT> >(functor));
DoInvoke(thread, closure, id);
@@ -87,8 +85,8 @@
template <class ReturnT, class FunctorT>
void AsyncInvokeDelayed(Thread* thread,
const FunctorT& functor,
- uint32 delay_ms,
- uint32 id = 0) {
+ uint32_t delay_ms,
+ uint32_t id = 0) {
scoped_refptr<AsyncClosure> closure(
new RefCountedObject<FireAndForgetAsyncClosure<FunctorT> >(functor));
DoInvokeDelayed(thread, closure, delay_ms, id);
@@ -100,7 +98,7 @@
const FunctorT& functor,
void (HostT::*callback)(ReturnT),
HostT* callback_host,
- uint32 id = 0) {
+ uint32_t id = 0) {
scoped_refptr<AsyncClosure> closure(
new RefCountedObject<NotifyingAsyncClosure<ReturnT, FunctorT, HostT> >(
this, Thread::Current(), functor, callback, callback_host));
@@ -114,7 +112,7 @@
const FunctorT& functor,
void (HostT::*callback)(),
HostT* callback_host,
- uint32 id = 0) {
+ uint32_t id = 0) {
scoped_refptr<AsyncClosure> closure(
new RefCountedObject<NotifyingAsyncClosure<void, FunctorT, HostT> >(
this, Thread::Current(), functor, callback, callback_host));
@@ -126,19 +124,20 @@
// before returning. Optionally filter by message id.
// The destructor will not wait for outstanding calls, so if that
// behavior is desired, call Flush() before destroying this object.
- void Flush(Thread* thread, uint32 id = MQID_ANY);
+ void Flush(Thread* thread, uint32_t id = MQID_ANY);
// Signaled when this object is destructed.
sigslot::signal0<> SignalInvokerDestroyed;
private:
void OnMessage(Message* msg) override;
- void DoInvoke(Thread* thread, const scoped_refptr<AsyncClosure>& closure,
- uint32 id);
+ void DoInvoke(Thread* thread,
+ const scoped_refptr<AsyncClosure>& closure,
+ uint32_t id);
void DoInvokeDelayed(Thread* thread,
const scoped_refptr<AsyncClosure>& closure,
- uint32 delay_ms,
- uint32 id);
+ uint32_t delay_ms,
+ uint32_t id);
bool destroying_;
RTC_DISALLOW_COPY_AND_ASSIGN(AsyncInvoker);
@@ -159,12 +158,12 @@
// complete before returning. Optionally filter by message id. The destructor
// will not wait for outstanding calls, so if that behavior is desired, call
// Flush() first. Returns false if the thread has died.
- bool Flush(uint32 id = MQID_ANY);
+ bool Flush(uint32_t id = MQID_ANY);
// Call |functor| asynchronously with no callback upon completion. Returns
// immediately. Returns false if the thread has died.
template <class ReturnT, class FunctorT>
- bool AsyncInvoke(const FunctorT& functor, uint32 id = 0) {
+ bool AsyncInvoke(const FunctorT& functor, uint32_t id = 0) {
rtc::CritScope cs(&crit_);
if (thread_ == nullptr)
return false;
@@ -176,8 +175,8 @@
// completion. Returns immediately. Returns false if the thread has died.
template <class ReturnT, class FunctorT>
bool AsyncInvokeDelayed(const FunctorT& functor,
- uint32 delay_ms,
- uint32 id = 0) {
+ uint32_t delay_ms,
+ uint32_t id = 0) {
rtc::CritScope cs(&crit_);
if (thread_ == nullptr)
return false;
@@ -192,7 +191,7 @@
bool AsyncInvoke(const FunctorT& functor,
void (HostT::*callback)(ReturnT),
HostT* callback_host,
- uint32 id = 0) {
+ uint32_t id = 0) {
rtc::CritScope cs(&crit_);
if (thread_ == nullptr)
return false;
@@ -207,7 +206,7 @@
bool AsyncInvoke(const FunctorT& functor,
void (HostT::*callback)(),
HostT* callback_host,
- uint32 id = 0) {
+ uint32_t id = 0) {
rtc::CritScope cs(&crit_);
if (thread_ == nullptr)
return false;
diff --git a/webrtc/base/asyncpacketsocket.h b/webrtc/base/asyncpacketsocket.h
index f0c221d..07cacf7 100644
--- a/webrtc/base/asyncpacketsocket.h
+++ b/webrtc/base/asyncpacketsocket.h
@@ -28,7 +28,7 @@
int rtp_sendtime_extension_id; // extension header id present in packet.
std::vector<char> srtp_auth_key; // Authentication key.
int srtp_auth_tag_len; // Authentication tag length.
- int64 srtp_packet_index; // Required for Rtp Packet authentication.
+ int64_t srtp_packet_index; // Required for Rtp Packet authentication.
};
// This structure holds meta information for the packet which is about to send
@@ -45,19 +45,19 @@
// received by socket.
struct PacketTime {
PacketTime() : timestamp(-1), not_before(-1) {}
- PacketTime(int64 timestamp, int64 not_before)
- : timestamp(timestamp), not_before(not_before) {
- }
+ PacketTime(int64_t timestamp, int64_t not_before)
+ : timestamp(timestamp), not_before(not_before) {}
- int64 timestamp; // Receive time after socket delivers the data.
- int64 not_before; // Earliest possible time the data could have arrived,
- // indicating the potential error in the |timestamp| value,
- // in case the system, is busy. For example, the time of
- // the last select() call.
- // If unknown, this value will be set to zero.
+ int64_t timestamp; // Receive time after socket delivers the data.
+
+ // Earliest possible time the data could have arrived, indicating the
+ // potential error in the |timestamp| value, in case the system, is busy. For
+ // example, the time of the last select() call.
+ // If unknown, this value will be set to zero.
+ int64_t not_before;
};
-inline PacketTime CreatePacketTime(int64 not_before) {
+inline PacketTime CreatePacketTime(int64_t not_before) {
return PacketTime(TimeMicros(), not_before);
}
diff --git a/webrtc/base/asyncsocket.cc b/webrtc/base/asyncsocket.cc
index dc0de3d..db451c6 100644
--- a/webrtc/base/asyncsocket.cc
+++ b/webrtc/base/asyncsocket.cc
@@ -96,7 +96,7 @@
return socket_->GetState();
}
-int AsyncSocketAdapter::EstimateMTU(uint16* mtu) {
+int AsyncSocketAdapter::EstimateMTU(uint16_t* mtu) {
return socket_->EstimateMTU(mtu);
}
diff --git a/webrtc/base/asyncsocket.h b/webrtc/base/asyncsocket.h
index 37bad4c..7a859be 100644
--- a/webrtc/base/asyncsocket.h
+++ b/webrtc/base/asyncsocket.h
@@ -64,7 +64,7 @@
int GetError() const override;
void SetError(int error) override;
ConnState GetState() const override;
- int EstimateMTU(uint16* mtu) override;
+ int EstimateMTU(uint16_t* mtu) override;
int GetOption(Option opt, int* value) override;
int SetOption(Option opt, int value) override;
diff --git a/webrtc/base/asynctcpsocket.cc b/webrtc/base/asynctcpsocket.cc
index 97d1e17..66fd3f1 100644
--- a/webrtc/base/asynctcpsocket.cc
+++ b/webrtc/base/asynctcpsocket.cc
@@ -24,7 +24,7 @@
static const size_t kMaxPacketSize = 64 * 1024;
-typedef uint16 PacketLength;
+typedef uint16_t PacketLength;
static const size_t kPacketLenSize = sizeof(PacketLength);
static const size_t kBufSize = kMaxPacketSize + kPacketLenSize;
diff --git a/webrtc/base/autodetectproxy.cc b/webrtc/base/autodetectproxy.cc
index 4ebc2d4..22950fb 100644
--- a/webrtc/base/autodetectproxy.cc
+++ b/webrtc/base/autodetectproxy.cc
@@ -102,7 +102,7 @@
IPAddress address_ip = proxy().address.ipaddr();
- uint16 address_port = proxy().address.port();
+ uint16_t address_port = proxy().address.port();
char autoconfig_url[kSavedStringLimit];
SaveStringToStack(autoconfig_url,
diff --git a/webrtc/base/autodetectproxy_unittest.cc b/webrtc/base/autodetectproxy_unittest.cc
index 4a26882..bc57304 100644
--- a/webrtc/base/autodetectproxy_unittest.cc
+++ b/webrtc/base/autodetectproxy_unittest.cc
@@ -19,7 +19,7 @@
static const char kUserAgent[] = "";
static const char kPath[] = "/";
static const char kHost[] = "relay.google.com";
-static const uint16 kPort = 443;
+static const uint16_t kPort = 443;
static const bool kSecure = true;
// At most, AutoDetectProxy should take ~6 seconds. Each connect step is
// allotted 2 seconds, with the initial resolution + connect given an
@@ -37,10 +37,10 @@
AutoDetectProxyTest() : auto_detect_proxy_(NULL), done_(false) {}
protected:
- bool Create(const std::string &user_agent,
- const std::string &path,
- const std::string &host,
- uint16 port,
+ bool Create(const std::string& user_agent,
+ const std::string& path,
+ const std::string& host,
+ uint16_t port,
bool secure,
bool startnow) {
auto_detect_proxy_ = new AutoDetectProxy(user_agent);
diff --git a/webrtc/base/bandwidthsmoother.cc b/webrtc/base/bandwidthsmoother.cc
index 09c7b99..d48c12e 100644
--- a/webrtc/base/bandwidthsmoother.cc
+++ b/webrtc/base/bandwidthsmoother.cc
@@ -16,7 +16,7 @@
namespace rtc {
BandwidthSmoother::BandwidthSmoother(int initial_bandwidth_guess,
- uint32 time_between_increase,
+ uint32_t time_between_increase,
double percent_increase,
size_t samples_count_to_average,
double min_sample_count_percent)
@@ -33,7 +33,7 @@
// Samples a new bandwidth measurement
// returns true if the bandwidth estimation changed
-bool BandwidthSmoother::Sample(uint32 sample_time, int bandwidth) {
+bool BandwidthSmoother::Sample(uint32_t sample_time, int bandwidth) {
if (bandwidth < 0) {
return false;
}
diff --git a/webrtc/base/bandwidthsmoother.h b/webrtc/base/bandwidthsmoother.h
index dbb4c81..eae565ea 100644
--- a/webrtc/base/bandwidthsmoother.h
+++ b/webrtc/base/bandwidthsmoother.h
@@ -31,7 +31,7 @@
class BandwidthSmoother {
public:
BandwidthSmoother(int initial_bandwidth_guess,
- uint32 time_between_increase,
+ uint32_t time_between_increase,
double percent_increase,
size_t samples_count_to_average,
double min_sample_count_percent);
@@ -40,16 +40,16 @@
// Samples a new bandwidth measurement.
// bandwidth is expected to be non-negative.
// returns true if the bandwidth estimation changed
- bool Sample(uint32 sample_time, int bandwidth);
+ bool Sample(uint32_t sample_time, int bandwidth);
int get_bandwidth_estimation() const {
return bandwidth_estimation_;
}
private:
- uint32 time_between_increase_;
+ uint32_t time_between_increase_;
double percent_increase_;
- uint32 time_at_last_change_;
+ uint32_t time_at_last_change_;
int bandwidth_estimation_;
RollingAccumulator<int> accumulator_;
double min_sample_count_percent_;
diff --git a/webrtc/base/basictypes_unittest.cc b/webrtc/base/basictypes_unittest.cc
index 4e243fd..df5ed5e 100644
--- a/webrtc/base/basictypes_unittest.cc
+++ b/webrtc/base/basictypes_unittest.cc
@@ -14,18 +14,9 @@
namespace rtc {
-static_assert(sizeof(int8) == 1, "Unexpected size");
-static_assert(sizeof(uint8) == 1, "Unexpected size");
-static_assert(sizeof(int16) == 2, "Unexpected size");
-static_assert(sizeof(uint16) == 2, "Unexpected size");
-static_assert(sizeof(int32) == 4, "Unexpected size");
-static_assert(sizeof(uint32) == 4, "Unexpected size");
-static_assert(sizeof(int64) == 8, "Unexpected size");
-static_assert(sizeof(uint64) == 8, "Unexpected size");
-
TEST(BasicTypesTest, Endian) {
- uint16 v16 = 0x1234u;
- uint8 first_byte = *reinterpret_cast<uint8*>(&v16);
+ uint16_t v16 = 0x1234u;
+ uint8_t first_byte = *reinterpret_cast<uint8_t*>(&v16);
#if defined(RTC_ARCH_CPU_LITTLE_ENDIAN)
EXPECT_EQ(0x34u, first_byte);
#elif defined(RTC_ARCH_CPU_BIG_ENDIAN)
@@ -33,33 +24,6 @@
#endif
}
-TEST(BasicTypesTest, SizeOfTypes) {
- int8 i8 = -1;
- uint8 u8 = 1u;
- int16 i16 = -1;
- uint16 u16 = 1u;
- int32 i32 = -1;
- uint32 u32 = 1u;
- int64 i64 = -1;
- uint64 u64 = 1u;
- EXPECT_EQ(1u, sizeof(i8));
- EXPECT_EQ(1u, sizeof(u8));
- EXPECT_EQ(2u, sizeof(i16));
- EXPECT_EQ(2u, sizeof(u16));
- EXPECT_EQ(4u, sizeof(i32));
- EXPECT_EQ(4u, sizeof(u32));
- EXPECT_EQ(8u, sizeof(i64));
- EXPECT_EQ(8u, sizeof(u64));
- EXPECT_GT(0, i8);
- EXPECT_LT(0u, u8);
- EXPECT_GT(0, i16);
- EXPECT_LT(0u, u16);
- EXPECT_GT(0, i32);
- EXPECT_LT(0u, u32);
- EXPECT_GT(0, i64);
- EXPECT_LT(0u, u64);
-}
-
TEST(BasicTypesTest, SizeOfConstants) {
EXPECT_EQ(8u, sizeof(INT64_C(0)));
EXPECT_EQ(8u, sizeof(UINT64_C(0)));
diff --git a/webrtc/base/bitbuffer_unittest.cc b/webrtc/base/bitbuffer_unittest.cc
index b9c348e..99701f7 100644
--- a/webrtc/base/bitbuffer_unittest.cc
+++ b/webrtc/base/bitbuffer_unittest.cc
@@ -16,9 +16,9 @@
namespace rtc {
TEST(BitBufferTest, ConsumeBits) {
- const uint8 bytes[64] = {0};
+ const uint8_t bytes[64] = {0};
BitBuffer buffer(bytes, 32);
- uint64 total_bits = 32 * 8;
+ uint64_t total_bits = 32 * 8;
EXPECT_EQ(total_bits, buffer.RemainingBitCount());
EXPECT_TRUE(buffer.ConsumeBits(3));
total_bits -= 3;
@@ -38,10 +38,10 @@
}
TEST(BitBufferTest, ReadBytesAligned) {
- const uint8 bytes[] = {0x0A, 0xBC, 0xDE, 0xF1, 0x23, 0x45, 0x67, 0x89};
- uint8 val8;
- uint16 val16;
- uint32 val32;
+ const uint8_t bytes[] = {0x0A, 0xBC, 0xDE, 0xF1, 0x23, 0x45, 0x67, 0x89};
+ uint8_t val8;
+ uint16_t val16;
+ uint32_t val32;
BitBuffer buffer(bytes, 8);
EXPECT_TRUE(buffer.ReadUInt8(&val8));
EXPECT_EQ(0x0Au, val8);
@@ -54,10 +54,11 @@
}
TEST(BitBufferTest, ReadBytesOffset4) {
- const uint8 bytes[] = {0x0A, 0xBC, 0xDE, 0xF1, 0x23, 0x45, 0x67, 0x89, 0x0A};
- uint8 val8;
- uint16 val16;
- uint32 val32;
+ const uint8_t bytes[] = {0x0A, 0xBC, 0xDE, 0xF1, 0x23,
+ 0x45, 0x67, 0x89, 0x0A};
+ uint8_t val8;
+ uint16_t val16;
+ uint32_t val32;
BitBuffer buffer(bytes, 9);
EXPECT_TRUE(buffer.ConsumeBits(4));
@@ -88,11 +89,11 @@
// The bytes. It almost looks like counting down by two at a time, except the
// jump at 5->3->0, since that's when the high bit is turned off.
- const uint8 bytes[] = {0x1F, 0xDB, 0x97, 0x53, 0x0E, 0xCA, 0x86, 0x42};
+ const uint8_t bytes[] = {0x1F, 0xDB, 0x97, 0x53, 0x0E, 0xCA, 0x86, 0x42};
- uint8 val8;
- uint16 val16;
- uint32 val32;
+ uint8_t val8;
+ uint16_t val16;
+ uint32_t val32;
BitBuffer buffer(bytes, 8);
EXPECT_TRUE(buffer.ConsumeBits(3));
EXPECT_TRUE(buffer.ReadUInt8(&val8));
@@ -101,7 +102,7 @@
EXPECT_EQ(0xDCBAu, val16);
EXPECT_TRUE(buffer.ReadUInt32(&val32));
EXPECT_EQ(0x98765432u, val32);
- // 5 bits left unread. Not enough to read a uint8.
+ // 5 bits left unread. Not enough to read a uint8_t.
EXPECT_EQ(5u, buffer.RemainingBitCount());
EXPECT_FALSE(buffer.ReadUInt8(&val8));
}
@@ -110,7 +111,7 @@
// Bit values are:
// 0b01001101,
// 0b00110010
- const uint8 bytes[] = {0x4D, 0x32};
+ const uint8_t bytes[] = {0x4D, 0x32};
uint32_t val;
BitBuffer buffer(bytes, 2);
EXPECT_TRUE(buffer.ReadBits(&val, 3));
@@ -136,7 +137,7 @@
}
TEST(BitBufferTest, SetOffsetValues) {
- uint8 bytes[4] = {0};
+ uint8_t bytes[4] = {0};
BitBufferWriter buffer(bytes, 4);
size_t byte_offset, bit_offset;
@@ -174,31 +175,31 @@
#endif
}
-uint64 GolombEncoded(uint32 val) {
+uint64_t GolombEncoded(uint32_t val) {
val++;
- uint32 bit_counter = val;
- uint64 bit_count = 0;
+ uint32_t bit_counter = val;
+ uint64_t bit_count = 0;
while (bit_counter > 0) {
bit_count++;
bit_counter >>= 1;
}
- return static_cast<uint64>(val) << (64 - (bit_count * 2 - 1));
+ return static_cast<uint64_t>(val) << (64 - (bit_count * 2 - 1));
}
TEST(BitBufferTest, GolombUint32Values) {
ByteBuffer byteBuffer;
byteBuffer.Resize(16);
- BitBuffer buffer(reinterpret_cast<const uint8*>(byteBuffer.Data()),
+ BitBuffer buffer(reinterpret_cast<const uint8_t*>(byteBuffer.Data()),
byteBuffer.Capacity());
- // Test over the uint32 range with a large enough step that the test doesn't
+ // Test over the uint32_t range with a large enough step that the test doesn't
// take forever. Around 20,000 iterations should do.
- const int kStep = std::numeric_limits<uint32>::max() / 20000;
- for (uint32 i = 0; i < std::numeric_limits<uint32>::max() - kStep;
+ const int kStep = std::numeric_limits<uint32_t>::max() / 20000;
+ for (uint32_t i = 0; i < std::numeric_limits<uint32_t>::max() - kStep;
i += kStep) {
- uint64 encoded_val = GolombEncoded(i);
+ uint64_t encoded_val = GolombEncoded(i);
byteBuffer.Clear();
byteBuffer.WriteUInt64(encoded_val);
- uint32 decoded_val;
+ uint32_t decoded_val;
EXPECT_TRUE(buffer.Seek(0, 0));
EXPECT_TRUE(buffer.ReadExponentialGolomb(&decoded_val));
EXPECT_EQ(i, decoded_val);
@@ -225,11 +226,11 @@
}
TEST(BitBufferTest, NoGolombOverread) {
- const uint8 bytes[] = {0x00, 0xFF, 0xFF};
+ const uint8_t bytes[] = {0x00, 0xFF, 0xFF};
// Make sure the bit buffer correctly enforces byte length on golomb reads.
// If it didn't, the above buffer would be valid at 3 bytes.
BitBuffer buffer(bytes, 1);
- uint32 decoded_val;
+ uint32_t decoded_val;
EXPECT_FALSE(buffer.ReadExponentialGolomb(&decoded_val));
BitBuffer longer_buffer(bytes, 2);
@@ -243,7 +244,7 @@
}
TEST(BitBufferWriterTest, SymmetricReadWrite) {
- uint8 bytes[16] = {0};
+ uint8_t bytes[16] = {0};
BitBufferWriter buffer(bytes, 4);
// Write some bit data at various sizes.
@@ -257,7 +258,7 @@
EXPECT_FALSE(buffer.WriteBits(1, 1));
EXPECT_TRUE(buffer.Seek(0, 0));
- uint32 val;
+ uint32_t val;
EXPECT_TRUE(buffer.ReadBits(&val, 3));
EXPECT_EQ(0x2u, val);
EXPECT_TRUE(buffer.ReadBits(&val, 2));
@@ -275,7 +276,7 @@
}
TEST(BitBufferWriterTest, SymmetricBytesMisaligned) {
- uint8 bytes[16] = {0};
+ uint8_t bytes[16] = {0};
BitBufferWriter buffer(bytes, 16);
// Offset 3, to get things misaligned.
@@ -285,9 +286,9 @@
EXPECT_TRUE(buffer.WriteUInt32(0x789ABCDEu));
buffer.Seek(0, 3);
- uint8 val8;
- uint16 val16;
- uint32 val32;
+ uint8_t val8;
+ uint16_t val16;
+ uint32_t val32;
EXPECT_TRUE(buffer.ReadUInt8(&val8));
EXPECT_EQ(0x12u, val8);
EXPECT_TRUE(buffer.ReadUInt16(&val16));
@@ -298,22 +299,22 @@
TEST(BitBufferWriterTest, SymmetricGolomb) {
char test_string[] = "my precious";
- uint8 bytes[64] = {0};
+ uint8_t bytes[64] = {0};
BitBufferWriter buffer(bytes, 64);
for (size_t i = 0; i < ARRAY_SIZE(test_string); ++i) {
EXPECT_TRUE(buffer.WriteExponentialGolomb(test_string[i]));
}
buffer.Seek(0, 0);
for (size_t i = 0; i < ARRAY_SIZE(test_string); ++i) {
- uint32 val;
+ uint32_t val;
EXPECT_TRUE(buffer.ReadExponentialGolomb(&val));
- EXPECT_LE(val, std::numeric_limits<uint8>::max());
+ EXPECT_LE(val, std::numeric_limits<uint8_t>::max());
EXPECT_EQ(test_string[i], static_cast<char>(val));
}
}
TEST(BitBufferWriterTest, WriteClearsBits) {
- uint8 bytes[] = {0xFF, 0xFF};
+ uint8_t bytes[] = {0xFF, 0xFF};
BitBufferWriter buffer(bytes, 2);
EXPECT_TRUE(buffer.ConsumeBits(3));
EXPECT_TRUE(buffer.WriteBits(0, 1));
diff --git a/webrtc/base/bytebuffer.cc b/webrtc/base/bytebuffer.cc
index 4b6a1d8..8bc1f23 100644
--- a/webrtc/base/bytebuffer.cc
+++ b/webrtc/base/bytebuffer.cc
@@ -66,16 +66,16 @@
delete[] bytes_;
}
-bool ByteBuffer::ReadUInt8(uint8* val) {
+bool ByteBuffer::ReadUInt8(uint8_t* val) {
if (!val) return false;
return ReadBytes(reinterpret_cast<char*>(val), 1);
}
-bool ByteBuffer::ReadUInt16(uint16* val) {
+bool ByteBuffer::ReadUInt16(uint16_t* val) {
if (!val) return false;
- uint16 v;
+ uint16_t v;
if (!ReadBytes(reinterpret_cast<char*>(&v), 2)) {
return false;
} else {
@@ -84,10 +84,10 @@
}
}
-bool ByteBuffer::ReadUInt24(uint32* val) {
+bool ByteBuffer::ReadUInt24(uint32_t* val) {
if (!val) return false;
- uint32 v = 0;
+ uint32_t v = 0;
char* read_into = reinterpret_cast<char*>(&v);
if (byte_order_ == ORDER_NETWORK || IsHostBigEndian()) {
++read_into;
@@ -101,10 +101,10 @@
}
}
-bool ByteBuffer::ReadUInt32(uint32* val) {
+bool ByteBuffer::ReadUInt32(uint32_t* val) {
if (!val) return false;
- uint32 v;
+ uint32_t v;
if (!ReadBytes(reinterpret_cast<char*>(&v), 4)) {
return false;
} else {
@@ -113,10 +113,10 @@
}
}
-bool ByteBuffer::ReadUInt64(uint64* val) {
+bool ByteBuffer::ReadUInt64(uint64_t* val) {
if (!val) return false;
- uint64 v;
+ uint64_t v;
if (!ReadBytes(reinterpret_cast<char*>(&v), 8)) {
return false;
} else {
@@ -147,17 +147,17 @@
}
}
-void ByteBuffer::WriteUInt8(uint8 val) {
+void ByteBuffer::WriteUInt8(uint8_t val) {
WriteBytes(reinterpret_cast<const char*>(&val), 1);
}
-void ByteBuffer::WriteUInt16(uint16 val) {
- uint16 v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork16(val) : val;
+void ByteBuffer::WriteUInt16(uint16_t val) {
+ uint16_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork16(val) : val;
WriteBytes(reinterpret_cast<const char*>(&v), 2);
}
-void ByteBuffer::WriteUInt24(uint32 val) {
- uint32 v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork32(val) : val;
+void ByteBuffer::WriteUInt24(uint32_t val) {
+ uint32_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork32(val) : val;
char* start = reinterpret_cast<char*>(&v);
if (byte_order_ == ORDER_NETWORK || IsHostBigEndian()) {
++start;
@@ -165,13 +165,13 @@
WriteBytes(start, 3);
}
-void ByteBuffer::WriteUInt32(uint32 val) {
- uint32 v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork32(val) : val;
+void ByteBuffer::WriteUInt32(uint32_t val) {
+ uint32_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork32(val) : val;
WriteBytes(reinterpret_cast<const char*>(&v), 4);
}
-void ByteBuffer::WriteUInt64(uint64 val) {
- uint64 v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork64(val) : val;
+void ByteBuffer::WriteUInt64(uint64_t val) {
+ uint64_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork64(val) : val;
WriteBytes(reinterpret_cast<const char*>(&v), 8);
}
diff --git a/webrtc/base/bytebuffer.h b/webrtc/base/bytebuffer.h
index 6cab2a8..ad2e552 100644
--- a/webrtc/base/bytebuffer.h
+++ b/webrtc/base/bytebuffer.h
@@ -47,11 +47,11 @@
// Read a next value from the buffer. Return false if there isn't
// enough data left for the specified type.
- bool ReadUInt8(uint8* val);
- bool ReadUInt16(uint16* val);
- bool ReadUInt24(uint32* val);
- bool ReadUInt32(uint32* val);
- bool ReadUInt64(uint64* val);
+ bool ReadUInt8(uint8_t* val);
+ bool ReadUInt16(uint16_t* val);
+ bool ReadUInt24(uint32_t* val);
+ bool ReadUInt32(uint32_t* val);
+ bool ReadUInt64(uint64_t* val);
bool ReadBytes(char* val, size_t len);
// Appends next |len| bytes from the buffer to |val|. Returns false
@@ -60,11 +60,11 @@
// Write value to the buffer. Resizes the buffer when it is
// neccessary.
- void WriteUInt8(uint8 val);
- void WriteUInt16(uint16 val);
- void WriteUInt24(uint32 val);
- void WriteUInt32(uint32 val);
- void WriteUInt64(uint64 val);
+ void WriteUInt8(uint8_t val);
+ void WriteUInt16(uint16_t val);
+ void WriteUInt24(uint32_t val);
+ void WriteUInt32(uint32_t val);
+ void WriteUInt64(uint64_t val);
void WriteString(const std::string& val);
void WriteBytes(const char* val, size_t len);
diff --git a/webrtc/base/bytebuffer_unittest.cc b/webrtc/base/bytebuffer_unittest.cc
index f4b0504..56b0e05 100644
--- a/webrtc/base/bytebuffer_unittest.cc
+++ b/webrtc/base/bytebuffer_unittest.cc
@@ -16,9 +16,9 @@
namespace rtc {
TEST(ByteBufferTest, TestByteOrder) {
- uint16 n16 = 1;
- uint32 n32 = 1;
- uint64 n64 = 1;
+ uint16_t n16 = 1;
+ uint32_t n32 = 1;
+ uint64_t n64 = 1;
EXPECT_EQ(n16, NetworkToHost16(HostToNetwork16(n16)));
EXPECT_EQ(n32, NetworkToHost32(HostToNetwork32(n32)));
@@ -117,45 +117,45 @@
for (size_t i = 0; i < ARRAY_SIZE(orders); i++) {
ByteBuffer buffer(orders[i]);
EXPECT_EQ(orders[i], buffer.Order());
- uint8 ru8;
+ uint8_t ru8;
EXPECT_FALSE(buffer.ReadUInt8(&ru8));
- // Write and read uint8.
- uint8 wu8 = 1;
+ // Write and read uint8_t.
+ uint8_t wu8 = 1;
buffer.WriteUInt8(wu8);
EXPECT_TRUE(buffer.ReadUInt8(&ru8));
EXPECT_EQ(wu8, ru8);
EXPECT_EQ(0U, buffer.Length());
- // Write and read uint16.
- uint16 wu16 = (1 << 8) + 1;
+ // Write and read uint16_t.
+ uint16_t wu16 = (1 << 8) + 1;
buffer.WriteUInt16(wu16);
- uint16 ru16;
+ uint16_t ru16;
EXPECT_TRUE(buffer.ReadUInt16(&ru16));
EXPECT_EQ(wu16, ru16);
EXPECT_EQ(0U, buffer.Length());
// Write and read uint24.
- uint32 wu24 = (3 << 16) + (2 << 8) + 1;
+ uint32_t wu24 = (3 << 16) + (2 << 8) + 1;
buffer.WriteUInt24(wu24);
- uint32 ru24;
+ uint32_t ru24;
EXPECT_TRUE(buffer.ReadUInt24(&ru24));
EXPECT_EQ(wu24, ru24);
EXPECT_EQ(0U, buffer.Length());
- // Write and read uint32.
- uint32 wu32 = (4 << 24) + (3 << 16) + (2 << 8) + 1;
+ // Write and read uint32_t.
+ uint32_t wu32 = (4 << 24) + (3 << 16) + (2 << 8) + 1;
buffer.WriteUInt32(wu32);
- uint32 ru32;
+ uint32_t ru32;
EXPECT_TRUE(buffer.ReadUInt32(&ru32));
EXPECT_EQ(wu32, ru32);
EXPECT_EQ(0U, buffer.Length());
- // Write and read uint64.
- uint32 another32 = (8 << 24) + (7 << 16) + (6 << 8) + 5;
- uint64 wu64 = (static_cast<uint64>(another32) << 32) + wu32;
+ // Write and read uint64_t.
+ uint32_t another32 = (8 << 24) + (7 << 16) + (6 << 8) + 5;
+ uint64_t wu64 = (static_cast<uint64_t>(another32) << 32) + wu32;
buffer.WriteUInt64(wu64);
- uint64 ru64;
+ uint64_t ru64;
EXPECT_TRUE(buffer.ReadUInt64(&ru64));
EXPECT_EQ(wu64, ru64);
EXPECT_EQ(0U, buffer.Length());
diff --git a/webrtc/base/byteorder.h b/webrtc/base/byteorder.h
index d907d9e..d579e6e 100644
--- a/webrtc/base/byteorder.h
+++ b/webrtc/base/byteorder.h
@@ -27,104 +27,102 @@
// TODO: Optimized versions, with direct read/writes of
// integers in host-endian format, when the platform supports it.
-inline void Set8(void* memory, size_t offset, uint8 v) {
- static_cast<uint8*>(memory)[offset] = v;
+inline void Set8(void* memory, size_t offset, uint8_t v) {
+ static_cast<uint8_t*>(memory)[offset] = v;
}
-inline uint8 Get8(const void* memory, size_t offset) {
- return static_cast<const uint8*>(memory)[offset];
+inline uint8_t Get8(const void* memory, size_t offset) {
+ return static_cast<const uint8_t*>(memory)[offset];
}
-inline void SetBE16(void* memory, uint16 v) {
- Set8(memory, 0, static_cast<uint8>(v >> 8));
- Set8(memory, 1, static_cast<uint8>(v >> 0));
+inline void SetBE16(void* memory, uint16_t v) {
+ Set8(memory, 0, static_cast<uint8_t>(v >> 8));
+ Set8(memory, 1, static_cast<uint8_t>(v >> 0));
}
-inline void SetBE32(void* memory, uint32 v) {
- Set8(memory, 0, static_cast<uint8>(v >> 24));
- Set8(memory, 1, static_cast<uint8>(v >> 16));
- Set8(memory, 2, static_cast<uint8>(v >> 8));
- Set8(memory, 3, static_cast<uint8>(v >> 0));
+inline void SetBE32(void* memory, uint32_t v) {
+ Set8(memory, 0, static_cast<uint8_t>(v >> 24));
+ Set8(memory, 1, static_cast<uint8_t>(v >> 16));
+ Set8(memory, 2, static_cast<uint8_t>(v >> 8));
+ Set8(memory, 3, static_cast<uint8_t>(v >> 0));
}
-inline void SetBE64(void* memory, uint64 v) {
- Set8(memory, 0, static_cast<uint8>(v >> 56));
- Set8(memory, 1, static_cast<uint8>(v >> 48));
- Set8(memory, 2, static_cast<uint8>(v >> 40));
- Set8(memory, 3, static_cast<uint8>(v >> 32));
- Set8(memory, 4, static_cast<uint8>(v >> 24));
- Set8(memory, 5, static_cast<uint8>(v >> 16));
- Set8(memory, 6, static_cast<uint8>(v >> 8));
- Set8(memory, 7, static_cast<uint8>(v >> 0));
+inline void SetBE64(void* memory, uint64_t v) {
+ Set8(memory, 0, static_cast<uint8_t>(v >> 56));
+ Set8(memory, 1, static_cast<uint8_t>(v >> 48));
+ Set8(memory, 2, static_cast<uint8_t>(v >> 40));
+ Set8(memory, 3, static_cast<uint8_t>(v >> 32));
+ Set8(memory, 4, static_cast<uint8_t>(v >> 24));
+ Set8(memory, 5, static_cast<uint8_t>(v >> 16));
+ Set8(memory, 6, static_cast<uint8_t>(v >> 8));
+ Set8(memory, 7, static_cast<uint8_t>(v >> 0));
}
-inline uint16 GetBE16(const void* memory) {
- return static_cast<uint16>((Get8(memory, 0) << 8) |
- (Get8(memory, 1) << 0));
+inline uint16_t GetBE16(const void* memory) {
+ return static_cast<uint16_t>((Get8(memory, 0) << 8) | (Get8(memory, 1) << 0));
}
-inline uint32 GetBE32(const void* memory) {
- return (static_cast<uint32>(Get8(memory, 0)) << 24) |
- (static_cast<uint32>(Get8(memory, 1)) << 16) |
- (static_cast<uint32>(Get8(memory, 2)) << 8) |
- (static_cast<uint32>(Get8(memory, 3)) << 0);
+inline uint32_t GetBE32(const void* memory) {
+ return (static_cast<uint32_t>(Get8(memory, 0)) << 24) |
+ (static_cast<uint32_t>(Get8(memory, 1)) << 16) |
+ (static_cast<uint32_t>(Get8(memory, 2)) << 8) |
+ (static_cast<uint32_t>(Get8(memory, 3)) << 0);
}
-inline uint64 GetBE64(const void* memory) {
- return (static_cast<uint64>(Get8(memory, 0)) << 56) |
- (static_cast<uint64>(Get8(memory, 1)) << 48) |
- (static_cast<uint64>(Get8(memory, 2)) << 40) |
- (static_cast<uint64>(Get8(memory, 3)) << 32) |
- (static_cast<uint64>(Get8(memory, 4)) << 24) |
- (static_cast<uint64>(Get8(memory, 5)) << 16) |
- (static_cast<uint64>(Get8(memory, 6)) << 8) |
- (static_cast<uint64>(Get8(memory, 7)) << 0);
+inline uint64_t GetBE64(const void* memory) {
+ return (static_cast<uint64_t>(Get8(memory, 0)) << 56) |
+ (static_cast<uint64_t>(Get8(memory, 1)) << 48) |
+ (static_cast<uint64_t>(Get8(memory, 2)) << 40) |
+ (static_cast<uint64_t>(Get8(memory, 3)) << 32) |
+ (static_cast<uint64_t>(Get8(memory, 4)) << 24) |
+ (static_cast<uint64_t>(Get8(memory, 5)) << 16) |
+ (static_cast<uint64_t>(Get8(memory, 6)) << 8) |
+ (static_cast<uint64_t>(Get8(memory, 7)) << 0);
}
-inline void SetLE16(void* memory, uint16 v) {
- Set8(memory, 0, static_cast<uint8>(v >> 0));
- Set8(memory, 1, static_cast<uint8>(v >> 8));
+inline void SetLE16(void* memory, uint16_t v) {
+ Set8(memory, 0, static_cast<uint8_t>(v >> 0));
+ Set8(memory, 1, static_cast<uint8_t>(v >> 8));
}
-inline void SetLE32(void* memory, uint32 v) {
- Set8(memory, 0, static_cast<uint8>(v >> 0));
- Set8(memory, 1, static_cast<uint8>(v >> 8));
- Set8(memory, 2, static_cast<uint8>(v >> 16));
- Set8(memory, 3, static_cast<uint8>(v >> 24));
+inline void SetLE32(void* memory, uint32_t v) {
+ Set8(memory, 0, static_cast<uint8_t>(v >> 0));
+ Set8(memory, 1, static_cast<uint8_t>(v >> 8));
+ Set8(memory, 2, static_cast<uint8_t>(v >> 16));
+ Set8(memory, 3, static_cast<uint8_t>(v >> 24));
}
-inline void SetLE64(void* memory, uint64 v) {
- Set8(memory, 0, static_cast<uint8>(v >> 0));
- Set8(memory, 1, static_cast<uint8>(v >> 8));
- Set8(memory, 2, static_cast<uint8>(v >> 16));
- Set8(memory, 3, static_cast<uint8>(v >> 24));
- Set8(memory, 4, static_cast<uint8>(v >> 32));
- Set8(memory, 5, static_cast<uint8>(v >> 40));
- Set8(memory, 6, static_cast<uint8>(v >> 48));
- Set8(memory, 7, static_cast<uint8>(v >> 56));
+inline void SetLE64(void* memory, uint64_t v) {
+ Set8(memory, 0, static_cast<uint8_t>(v >> 0));
+ Set8(memory, 1, static_cast<uint8_t>(v >> 8));
+ Set8(memory, 2, static_cast<uint8_t>(v >> 16));
+ Set8(memory, 3, static_cast<uint8_t>(v >> 24));
+ Set8(memory, 4, static_cast<uint8_t>(v >> 32));
+ Set8(memory, 5, static_cast<uint8_t>(v >> 40));
+ Set8(memory, 6, static_cast<uint8_t>(v >> 48));
+ Set8(memory, 7, static_cast<uint8_t>(v >> 56));
}
-inline uint16 GetLE16(const void* memory) {
- return static_cast<uint16>((Get8(memory, 0) << 0) |
- (Get8(memory, 1) << 8));
+inline uint16_t GetLE16(const void* memory) {
+ return static_cast<uint16_t>((Get8(memory, 0) << 0) | (Get8(memory, 1) << 8));
}
-inline uint32 GetLE32(const void* memory) {
- return (static_cast<uint32>(Get8(memory, 0)) << 0) |
- (static_cast<uint32>(Get8(memory, 1)) << 8) |
- (static_cast<uint32>(Get8(memory, 2)) << 16) |
- (static_cast<uint32>(Get8(memory, 3)) << 24);
+inline uint32_t GetLE32(const void* memory) {
+ return (static_cast<uint32_t>(Get8(memory, 0)) << 0) |
+ (static_cast<uint32_t>(Get8(memory, 1)) << 8) |
+ (static_cast<uint32_t>(Get8(memory, 2)) << 16) |
+ (static_cast<uint32_t>(Get8(memory, 3)) << 24);
}
-inline uint64 GetLE64(const void* memory) {
- return (static_cast<uint64>(Get8(memory, 0)) << 0) |
- (static_cast<uint64>(Get8(memory, 1)) << 8) |
- (static_cast<uint64>(Get8(memory, 2)) << 16) |
- (static_cast<uint64>(Get8(memory, 3)) << 24) |
- (static_cast<uint64>(Get8(memory, 4)) << 32) |
- (static_cast<uint64>(Get8(memory, 5)) << 40) |
- (static_cast<uint64>(Get8(memory, 6)) << 48) |
- (static_cast<uint64>(Get8(memory, 7)) << 56);
+inline uint64_t GetLE64(const void* memory) {
+ return (static_cast<uint64_t>(Get8(memory, 0)) << 0) |
+ (static_cast<uint64_t>(Get8(memory, 1)) << 8) |
+ (static_cast<uint64_t>(Get8(memory, 2)) << 16) |
+ (static_cast<uint64_t>(Get8(memory, 3)) << 24) |
+ (static_cast<uint64_t>(Get8(memory, 4)) << 32) |
+ (static_cast<uint64_t>(Get8(memory, 5)) << 40) |
+ (static_cast<uint64_t>(Get8(memory, 6)) << 48) |
+ (static_cast<uint64_t>(Get8(memory, 7)) << 56);
}
// Check if the current host is big endian.
@@ -133,33 +131,33 @@
return 0 == *reinterpret_cast<const char*>(&number);
}
-inline uint16 HostToNetwork16(uint16 n) {
- uint16 result;
+inline uint16_t HostToNetwork16(uint16_t n) {
+ uint16_t result;
SetBE16(&result, n);
return result;
}
-inline uint32 HostToNetwork32(uint32 n) {
- uint32 result;
+inline uint32_t HostToNetwork32(uint32_t n) {
+ uint32_t result;
SetBE32(&result, n);
return result;
}
-inline uint64 HostToNetwork64(uint64 n) {
- uint64 result;
+inline uint64_t HostToNetwork64(uint64_t n) {
+ uint64_t result;
SetBE64(&result, n);
return result;
}
-inline uint16 NetworkToHost16(uint16 n) {
+inline uint16_t NetworkToHost16(uint16_t n) {
return GetBE16(&n);
}
-inline uint32 NetworkToHost32(uint32 n) {
+inline uint32_t NetworkToHost32(uint32_t n) {
return GetBE32(&n);
}
-inline uint64 NetworkToHost64(uint64 n) {
+inline uint64_t NetworkToHost64(uint64_t n) {
return GetBE64(&n);
}
diff --git a/webrtc/base/byteorder_unittest.cc b/webrtc/base/byteorder_unittest.cc
index f4e7df3..c3135aa 100644
--- a/webrtc/base/byteorder_unittest.cc
+++ b/webrtc/base/byteorder_unittest.cc
@@ -17,7 +17,7 @@
// Test memory set functions put values into memory in expected order.
TEST(ByteOrderTest, TestSet) {
- uint8 buf[8] = { 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u };
+ uint8_t buf[8] = {0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u};
Set8(buf, 0, 0xfb);
Set8(buf, 1, 0x12);
EXPECT_EQ(0xfb, buf[0]);
@@ -60,7 +60,7 @@
// Test memory get functions get values from memory in expected order.
TEST(ByteOrderTest, TestGet) {
- uint8 buf[8];
+ uint8_t buf[8];
buf[0] = 0x01u;
buf[1] = 0x23u;
buf[2] = 0x45u;
diff --git a/webrtc/base/crc32.cc b/webrtc/base/crc32.cc
index d643a25..eae338a 100644
--- a/webrtc/base/crc32.cc
+++ b/webrtc/base/crc32.cc
@@ -18,14 +18,14 @@
// CRC32 polynomial, in reversed form.
// See RFC 1952, or http://en.wikipedia.org/wiki/Cyclic_redundancy_check
-static const uint32 kCrc32Polynomial = 0xEDB88320;
-static uint32 kCrc32Table[256] = { 0 };
+static const uint32_t kCrc32Polynomial = 0xEDB88320;
+static uint32_t kCrc32Table[256] = {0};
static void EnsureCrc32TableInited() {
if (kCrc32Table[ARRAY_SIZE(kCrc32Table) - 1])
return; // already inited
- for (uint32 i = 0; i < ARRAY_SIZE(kCrc32Table); ++i) {
- uint32 c = i;
+ for (uint32_t i = 0; i < ARRAY_SIZE(kCrc32Table); ++i) {
+ uint32_t c = i;
for (size_t j = 0; j < 8; ++j) {
if (c & 1) {
c = kCrc32Polynomial ^ (c >> 1);
@@ -37,11 +37,11 @@
}
}
-uint32 UpdateCrc32(uint32 start, const void* buf, size_t len) {
+uint32_t UpdateCrc32(uint32_t start, const void* buf, size_t len) {
EnsureCrc32TableInited();
- uint32 c = start ^ 0xFFFFFFFF;
- const uint8* u = static_cast<const uint8*>(buf);
+ uint32_t c = start ^ 0xFFFFFFFF;
+ const uint8_t* u = static_cast<const uint8_t*>(buf);
for (size_t i = 0; i < len; ++i) {
c = kCrc32Table[(c ^ u[i]) & 0xFF] ^ (c >> 8);
}
diff --git a/webrtc/base/crc32.h b/webrtc/base/crc32.h
index 99b4cac..9661876 100644
--- a/webrtc/base/crc32.h
+++ b/webrtc/base/crc32.h
@@ -19,13 +19,13 @@
// Updates a CRC32 checksum with |len| bytes from |buf|. |initial| holds the
// checksum result from the previous update; for the first call, it should be 0.
-uint32 UpdateCrc32(uint32 initial, const void* buf, size_t len);
+uint32_t UpdateCrc32(uint32_t initial, const void* buf, size_t len);
// Computes a CRC32 checksum using |len| bytes from |buf|.
-inline uint32 ComputeCrc32(const void* buf, size_t len) {
+inline uint32_t ComputeCrc32(const void* buf, size_t len) {
return UpdateCrc32(0, buf, len);
}
-inline uint32 ComputeCrc32(const std::string& str) {
+inline uint32_t ComputeCrc32(const std::string& str) {
return ComputeCrc32(str.c_str(), str.size());
}
diff --git a/webrtc/base/crc32_unittest.cc b/webrtc/base/crc32_unittest.cc
index 0bfdeee..6da5c32 100644
--- a/webrtc/base/crc32_unittest.cc
+++ b/webrtc/base/crc32_unittest.cc
@@ -25,7 +25,7 @@
TEST(Crc32Test, TestMultipleUpdates) {
std::string input =
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
- uint32 c = 0;
+ uint32_t c = 0;
for (size_t i = 0; i < input.size(); ++i) {
c = UpdateCrc32(c, &input[i], 1);
}
diff --git a/webrtc/base/dbus_unittest.cc b/webrtc/base/dbus_unittest.cc
index 505ddbb..17752f1 100644
--- a/webrtc/base/dbus_unittest.cc
+++ b/webrtc/base/dbus_unittest.cc
@@ -18,7 +18,7 @@
#define SIG_NAME "NameAcquired"
-static const uint32 kTimeoutMs = 5000U;
+static const uint32_t kTimeoutMs = 5000U;
class DBusSigFilterTest : public DBusSigFilter {
public:
diff --git a/webrtc/base/faketaskrunner.h b/webrtc/base/faketaskrunner.h
index 5408ab8..88e4826 100644
--- a/webrtc/base/faketaskrunner.h
+++ b/webrtc/base/faketaskrunner.h
@@ -25,12 +25,12 @@
virtual void WakeTasks() { RunTasks(); }
- virtual int64 CurrentTime() {
+ virtual int64_t CurrentTime() {
// Implement if needed.
return current_time_++;
}
- int64 current_time_;
+ int64_t current_time_;
};
} // namespace rtc
diff --git a/webrtc/base/fileutils.h b/webrtc/base/fileutils.h
index 8d085ef..bf02571 100644
--- a/webrtc/base/fileutils.h
+++ b/webrtc/base/fileutils.h
@@ -234,7 +234,7 @@
// Delete the contents of the folder returned by GetAppTempFolder
bool CleanAppTempFolder();
- virtual bool GetDiskFreeSpace(const Pathname& path, int64 *freebytes) = 0;
+ virtual bool GetDiskFreeSpace(const Pathname& path, int64_t* freebytes) = 0;
// Returns the absolute path of the current directory.
virtual Pathname GetCurrentDirectory() = 0;
@@ -379,7 +379,7 @@
return EnsureDefaultFilesystem()->CleanAppTempFolder();
}
- static bool GetDiskFreeSpace(const Pathname& path, int64 *freebytes) {
+ static bool GetDiskFreeSpace(const Pathname& path, int64_t* freebytes) {
return EnsureDefaultFilesystem()->GetDiskFreeSpace(path, freebytes);
}
diff --git a/webrtc/base/fileutils_mock.h b/webrtc/base/fileutils_mock.h
index e9d20a7..428d444 100644
--- a/webrtc/base/fileutils_mock.h
+++ b/webrtc/base/fileutils_mock.h
@@ -237,7 +237,7 @@
EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
- bool GetDiskFreeSpace(const Pathname &path, int64 *freebytes) {
+ bool GetDiskFreeSpace(const Pathname& path, int64_t* freebytes) {
EXPECT_TRUE(false) << "Unsupported operation";
return false;
}
diff --git a/webrtc/base/fileutils_unittest.cc b/webrtc/base/fileutils_unittest.cc
index 9076bc7..6e98e14 100644
--- a/webrtc/base/fileutils_unittest.cc
+++ b/webrtc/base/fileutils_unittest.cc
@@ -90,29 +90,29 @@
Pathname path;
ASSERT_TRUE(Filesystem::GetAppDataFolder(&path, true));
- int64 free1 = 0;
+ int64_t free1 = 0;
EXPECT_TRUE(Filesystem::IsFolder(path));
EXPECT_FALSE(Filesystem::IsFile(path));
EXPECT_TRUE(Filesystem::GetDiskFreeSpace(path, &free1));
EXPECT_GT(free1, 0);
- int64 free2 = 0;
+ int64_t free2 = 0;
path.AppendFolder("this_folder_doesnt_exist");
EXPECT_FALSE(Filesystem::IsFolder(path));
EXPECT_TRUE(Filesystem::IsAbsent(path));
EXPECT_TRUE(Filesystem::GetDiskFreeSpace(path, &free2));
// These should be the same disk, and disk free space should not have changed
// by more than 1% between the two calls.
- EXPECT_LT(static_cast<int64>(free1 * .9), free2);
- EXPECT_LT(free2, static_cast<int64>(free1 * 1.1));
+ EXPECT_LT(static_cast<int64_t>(free1 * .9), free2);
+ EXPECT_LT(free2, static_cast<int64_t>(free1 * 1.1));
- int64 free3 = 0;
+ int64_t free3 = 0;
path.clear();
EXPECT_TRUE(path.empty());
EXPECT_TRUE(Filesystem::GetDiskFreeSpace(path, &free3));
// Current working directory may not be where exe is.
- // EXPECT_LT(static_cast<int64>(free1 * .9), free3);
- // EXPECT_LT(free3, static_cast<int64>(free1 * 1.1));
+ // EXPECT_LT(static_cast<int64_t>(free1 * .9), free3);
+ // EXPECT_LT(free3, static_cast<int64_t>(free1 * 1.1));
EXPECT_GT(free3, 0);
}
diff --git a/webrtc/base/gunit.h b/webrtc/base/gunit.h
index 7431fcf..c2bc844 100644
--- a/webrtc/base/gunit.h
+++ b/webrtc/base/gunit.h
@@ -20,22 +20,21 @@
#endif
// Wait until "ex" is true, or "timeout" expires.
-#define WAIT(ex, timeout) \
- for (uint32 start = rtc::Time(); \
- !(ex) && rtc::Time() < start + timeout;) \
+#define WAIT(ex, timeout) \
+ for (uint32_t start = rtc::Time(); !(ex) && rtc::Time() < start + timeout;) \
rtc::Thread::Current()->ProcessMessages(1);
// This returns the result of the test in res, so that we don't re-evaluate
// the expression in the XXXX_WAIT macros below, since that causes problems
// when the expression is only true the first time you check it.
-#define WAIT_(ex, timeout, res) \
- do { \
- uint32 start = rtc::Time(); \
- res = (ex); \
+#define WAIT_(ex, timeout, res) \
+ do { \
+ uint32_t start = rtc::Time(); \
+ res = (ex); \
while (!res && rtc::Time() < start + timeout) { \
- rtc::Thread::Current()->ProcessMessages(1); \
- res = (ex); \
- } \
+ rtc::Thread::Current()->ProcessMessages(1); \
+ res = (ex); \
+ } \
} while (0);
// The typical EXPECT_XXXX and ASSERT_XXXXs, but done until true or a timeout.
diff --git a/webrtc/base/helpers.cc b/webrtc/base/helpers.cc
index 0102c10..8e59b64 100644
--- a/webrtc/base/helpers.cc
+++ b/webrtc/base/helpers.cc
@@ -152,7 +152,7 @@
bool Init(const void* seed, size_t len) override { return true; }
bool Generate(void* buf, size_t len) override {
for (size_t i = 0; i < len; ++i) {
- static_cast<uint8*>(buf)[i] = static_cast<uint8>(GetRandom());
+ static_cast<uint8_t*>(buf)[i] = static_cast<uint8_t>(GetRandom());
}
return true;
}
@@ -219,7 +219,7 @@
const char* table, int table_size,
std::string* str) {
str->clear();
- scoped_ptr<uint8[]> bytes(new uint8[len]);
+ scoped_ptr<uint8_t[]> bytes(new uint8_t[len]);
if (!Rng().Generate(bytes.get(), len)) {
LOG(LS_ERROR) << "Failed to generate random string!";
return false;
@@ -241,20 +241,20 @@
static_cast<int>(table.size()), str);
}
-uint32 CreateRandomId() {
- uint32 id;
+uint32_t CreateRandomId() {
+ uint32_t id;
if (!Rng().Generate(&id, sizeof(id))) {
LOG(LS_ERROR) << "Failed to generate random id!";
}
return id;
}
-uint64 CreateRandomId64() {
- return static_cast<uint64>(CreateRandomId()) << 32 | CreateRandomId();
+uint64_t CreateRandomId64() {
+ return static_cast<uint64_t>(CreateRandomId()) << 32 | CreateRandomId();
}
-uint32 CreateRandomNonZeroId() {
- uint32 id;
+uint32_t CreateRandomNonZeroId() {
+ uint32_t id;
do {
id = CreateRandomId();
} while (id == 0);
@@ -262,8 +262,8 @@
}
double CreateRandomDouble() {
- return CreateRandomId() / (std::numeric_limits<uint32>::max() +
- std::numeric_limits<double>::epsilon());
+ return CreateRandomId() / (std::numeric_limits<uint32_t>::max() +
+ std::numeric_limits<double>::epsilon());
}
} // namespace rtc
diff --git a/webrtc/base/helpers.h b/webrtc/base/helpers.h
index e46d12a..102c08b 100644
--- a/webrtc/base/helpers.h
+++ b/webrtc/base/helpers.h
@@ -40,13 +40,13 @@
std::string* str);
// Generates a random id.
-uint32 CreateRandomId();
+uint32_t CreateRandomId();
// Generates a 64 bit random id.
-uint64 CreateRandomId64();
+uint64_t CreateRandomId64();
// Generates a random id > 0.
-uint32 CreateRandomNonZeroId();
+uint32_t CreateRandomNonZeroId();
// Generates a random double between 0.0 (inclusive) and 1.0 (exclusive).
double CreateRandomDouble();
diff --git a/webrtc/base/httpbase_unittest.cc b/webrtc/base/httpbase_unittest.cc
index d4dd775..8d8e097 100644
--- a/webrtc/base/httpbase_unittest.cc
+++ b/webrtc/base/httpbase_unittest.cc
@@ -145,7 +145,7 @@
std::string header;
EXPECT_EQ(HVER_1_1, data.version);
- EXPECT_EQ(static_cast<uint32>(HC_OK), data.scode);
+ EXPECT_EQ(static_cast<uint32_t>(HC_OK), data.scode);
EXPECT_TRUE(data.hasHeader(HH_PROXY_AUTHORIZATION, &header));
EXPECT_EQ("42", header);
EXPECT_TRUE(data.hasHeader(HH_CONNECTION, &header));
@@ -215,7 +215,7 @@
// HTTP headers haven't arrived yet
EXPECT_EQ(0U, events.size());
- EXPECT_EQ(static_cast<uint32>(HC_INTERNAL_SERVER_ERROR), data.scode);
+ EXPECT_EQ(static_cast<uint32_t>(HC_INTERNAL_SERVER_ERROR), data.scode);
LOG_F(LS_VERBOSE) << "Exit";
}
diff --git a/webrtc/base/httpcommon-inl.h b/webrtc/base/httpcommon-inl.h
index 2f525ce..d1c0bf0 100644
--- a/webrtc/base/httpcommon-inl.h
+++ b/webrtc/base/httpcommon-inl.h
@@ -52,7 +52,7 @@
host_.assign(val, colon - val);
// Note: In every case, we're guaranteed that colon is followed by a null,
// or non-numeric character.
- port_ = static_cast<uint16>(::strtoul(colon + 1, NULL, 10));
+ port_ = static_cast<uint16_t>(::strtoul(colon + 1, NULL, 10));
// TODO: Consider checking for invalid data following port number.
} else {
host_.assign(val, len);
diff --git a/webrtc/base/httpcommon.cc b/webrtc/base/httpcommon.cc
index 138ca42..0c3547e 100644
--- a/webrtc/base/httpcommon.cc
+++ b/webrtc/base/httpcommon.cc
@@ -149,12 +149,12 @@
return Enum<HttpHeader>::Parse(header, str);
}
-bool HttpCodeHasBody(uint32 code) {
+bool HttpCodeHasBody(uint32_t code) {
return !HttpCodeIsInformational(code)
&& (code != HC_NO_CONTENT) && (code != HC_NOT_MODIFIED);
}
-bool HttpCodeIsCacheable(uint32 code) {
+bool HttpCodeIsCacheable(uint32_t code) {
switch (code) {
case HC_OK:
case HC_NON_AUTHORITATIVE:
@@ -599,32 +599,29 @@
HttpData::copy(src);
}
-void
-HttpResponseData::set_success(uint32 scode) {
+void HttpResponseData::set_success(uint32_t scode) {
this->scode = scode;
message.clear();
setHeader(HH_CONTENT_LENGTH, "0", false);
}
-void
-HttpResponseData::set_success(const std::string& content_type,
- StreamInterface* document,
- uint32 scode) {
+void HttpResponseData::set_success(const std::string& content_type,
+ StreamInterface* document,
+ uint32_t scode) {
this->scode = scode;
message.erase(message.begin(), message.end());
setContent(content_type, document);
}
-void
-HttpResponseData::set_redirect(const std::string& location, uint32 scode) {
+void HttpResponseData::set_redirect(const std::string& location,
+ uint32_t scode) {
this->scode = scode;
message.clear();
setHeader(HH_LOCATION, location);
setHeader(HH_CONTENT_LENGTH, "0", false);
}
-void
-HttpResponseData::set_error(uint32 scode) {
+void HttpResponseData::set_error(uint32_t scode) {
this->scode = scode;
message.clear();
setHeader(HH_CONTENT_LENGTH, "0", false);
@@ -911,7 +908,7 @@
bool specify_credentials = !username.empty();
size_t steps = 0;
- //uint32 now = Time();
+ // uint32_t now = Time();
NegotiateAuthContext * neg = static_cast<NegotiateAuthContext *>(context);
if (neg) {
diff --git a/webrtc/base/httpcommon.h b/webrtc/base/httpcommon.h
index 7b20fac..addc1bc 100644
--- a/webrtc/base/httpcommon.h
+++ b/webrtc/base/httpcommon.h
@@ -112,8 +112,8 @@
HH_LAST = HH_WWW_AUTHENTICATE
};
-const uint16 HTTP_DEFAULT_PORT = 80;
-const uint16 HTTP_SECURE_PORT = 443;
+const uint16_t HTTP_DEFAULT_PORT = 80;
+const uint16_t HTTP_SECURE_PORT = 443;
//////////////////////////////////////////////////////////////////////
// Utility Functions
@@ -132,14 +132,24 @@
const char* ToString(HttpHeader header);
bool FromString(HttpHeader& header, const std::string& str);
-inline bool HttpCodeIsInformational(uint32 code) { return ((code / 100) == 1); }
-inline bool HttpCodeIsSuccessful(uint32 code) { return ((code / 100) == 2); }
-inline bool HttpCodeIsRedirection(uint32 code) { return ((code / 100) == 3); }
-inline bool HttpCodeIsClientError(uint32 code) { return ((code / 100) == 4); }
-inline bool HttpCodeIsServerError(uint32 code) { return ((code / 100) == 5); }
+inline bool HttpCodeIsInformational(uint32_t code) {
+ return ((code / 100) == 1);
+}
+inline bool HttpCodeIsSuccessful(uint32_t code) {
+ return ((code / 100) == 2);
+}
+inline bool HttpCodeIsRedirection(uint32_t code) {
+ return ((code / 100) == 3);
+}
+inline bool HttpCodeIsClientError(uint32_t code) {
+ return ((code / 100) == 4);
+}
+inline bool HttpCodeIsServerError(uint32_t code) {
+ return ((code / 100) == 5);
+}
-bool HttpCodeHasBody(uint32 code);
-bool HttpCodeIsCacheable(uint32 code);
+bool HttpCodeHasBody(uint32_t code);
+bool HttpCodeIsCacheable(uint32_t code);
bool HttpHeaderIsEndToEnd(HttpHeader header);
bool HttpHeaderIsCollapsible(HttpHeader header);
@@ -163,7 +173,7 @@
// Convert RFC1123 date (DoW, DD Mon YYYY HH:MM:SS TZ) to unix timestamp
bool HttpDateToSeconds(const std::string& date, time_t* seconds);
-inline uint16 HttpDefaultPort(bool secure) {
+inline uint16_t HttpDefaultPort(bool secure) {
return secure ? HTTP_SECURE_PORT : HTTP_DEFAULT_PORT;
}
@@ -196,9 +206,10 @@
static int Decode(const string& source, string& destination);
Url(const string& url) { do_set_url(url.c_str(), url.size()); }
- Url(const string& path, const string& host, uint16 port = HTTP_DEFAULT_PORT)
- : host_(host), port_(port), secure_(HTTP_SECURE_PORT == port)
- { set_full_path(path); }
+ Url(const string& path, const string& host, uint16_t port = HTTP_DEFAULT_PORT)
+ : host_(host), port_(port), secure_(HTTP_SECURE_PORT == port) {
+ set_full_path(path);
+ }
bool valid() const { return !host_.empty(); }
void clear() {
@@ -233,8 +244,8 @@
void set_host(const string& val) { host_ = val; }
const string& host() const { return host_; }
- void set_port(uint16 val) { port_ = val; }
- uint16 port() const { return port_; }
+ void set_port(uint16_t val) { port_ = val; }
+ uint16_t port() const { return port_; }
void set_secure(bool val) { secure_ = val; }
bool secure() const { return secure_; }
@@ -267,7 +278,7 @@
void do_get_full_path(string* val) const;
string host_, path_, query_;
- uint16 port_;
+ uint16_t port_;
bool secure_;
};
@@ -393,7 +404,7 @@
};
struct HttpResponseData : public HttpData {
- uint32 scode;
+ uint32_t scode;
std::string message;
HttpResponseData() : scode(HC_INTERNAL_SERVER_ERROR) { }
@@ -401,12 +412,13 @@
void copy(const HttpResponseData& src);
// Convenience methods
- void set_success(uint32 scode = HC_OK);
- void set_success(const std::string& content_type, StreamInterface* document,
- uint32 scode = HC_OK);
+ void set_success(uint32_t scode = HC_OK);
+ void set_success(const std::string& content_type,
+ StreamInterface* document,
+ uint32_t scode = HC_OK);
void set_redirect(const std::string& location,
- uint32 scode = HC_MOVED_TEMPORARILY);
- void set_error(uint32 scode);
+ uint32_t scode = HC_MOVED_TEMPORARILY);
+ void set_error(uint32_t scode);
size_t formatLeader(char* buffer, size_t size) const override;
HttpError parseLeader(const char* line, size_t len) override;
diff --git a/webrtc/base/ipaddress.cc b/webrtc/base/ipaddress.cc
index 3dd856a..316207f 100644
--- a/webrtc/base/ipaddress.cc
+++ b/webrtc/base/ipaddress.cc
@@ -43,10 +43,10 @@
bool IPAddress::strip_sensitive_ = false;
-static bool IsPrivateV4(uint32 ip);
+static bool IsPrivateV4(uint32_t ip);
static in_addr ExtractMappedAddress(const in6_addr& addr);
-uint32 IPAddress::v4AddressAsHostOrderInteger() const {
+uint32_t IPAddress::v4AddressAsHostOrderInteger() const {
if (family_ == AF_INET) {
return NetworkToHost32(u_.ip4.s_addr);
} else {
@@ -215,7 +215,7 @@
return os;
}
-bool IsPrivateV4(uint32 ip_in_host_order) {
+bool IsPrivateV4(uint32_t ip_in_host_order) {
return ((ip_in_host_order >> 24) == 127) ||
((ip_in_host_order >> 24) == 10) ||
((ip_in_host_order >> 20) == ((172 << 4) | 1)) ||
@@ -321,8 +321,8 @@
}
case AF_INET6: {
in6_addr v6addr = ip.ipv6_address();
- const uint32* v6_as_ints =
- reinterpret_cast<const uint32*>(&v6addr.s6_addr);
+ const uint32_t* v6_as_ints =
+ reinterpret_cast<const uint32_t*>(&v6addr.s6_addr);
return v6_as_ints[0] ^ v6_as_ints[1] ^ v6_as_ints[2] ^ v6_as_ints[3];
}
}
@@ -341,7 +341,7 @@
return IPAddress(INADDR_ANY);
}
int mask = (0xFFFFFFFF << (32 - length));
- uint32 host_order_ip = NetworkToHost32(ip.ipv4_address().s_addr);
+ uint32_t host_order_ip = NetworkToHost32(ip.ipv4_address().s_addr);
in_addr masked;
masked.s_addr = HostToNetwork32(host_order_ip & mask);
return IPAddress(masked);
@@ -356,12 +356,11 @@
int position = length / 32;
int inner_length = 32 - (length - (position * 32));
// Note: 64bit mask constant needed to allow possible 32-bit left shift.
- uint32 inner_mask = 0xFFFFFFFFLL << inner_length;
- uint32* v6_as_ints =
- reinterpret_cast<uint32*>(&v6addr.s6_addr);
+ uint32_t inner_mask = 0xFFFFFFFFLL << inner_length;
+ uint32_t* v6_as_ints = reinterpret_cast<uint32_t*>(&v6addr.s6_addr);
for (int i = 0; i < 4; ++i) {
if (i == position) {
- uint32 host_order_inner = NetworkToHost32(v6_as_ints[i]);
+ uint32_t host_order_inner = NetworkToHost32(v6_as_ints[i]);
v6_as_ints[i] = HostToNetwork32(host_order_inner & inner_mask);
} else if (i > position) {
v6_as_ints[i] = 0;
@@ -373,7 +372,7 @@
}
int CountIPMaskBits(IPAddress mask) {
- uint32 word_to_count = 0;
+ uint32_t word_to_count = 0;
int bits = 0;
switch (mask.family()) {
case AF_INET: {
@@ -382,8 +381,8 @@
}
case AF_INET6: {
in6_addr v6addr = mask.ipv6_address();
- const uint32* v6_as_ints =
- reinterpret_cast<const uint32*>(&v6addr.s6_addr);
+ const uint32_t* v6_as_ints =
+ reinterpret_cast<const uint32_t*>(&v6addr.s6_addr);
int i = 0;
for (; i < 4; ++i) {
if (v6_as_ints[i] != 0xFFFFFFFF) {
@@ -408,7 +407,7 @@
// http://graphics.stanford.edu/~seander/bithacks.html
// Counts the trailing 0s in the word.
unsigned int zeroes = 32;
- word_to_count &= -static_cast<int32>(word_to_count);
+ word_to_count &= -static_cast<int32_t>(word_to_count);
if (word_to_count) zeroes--;
if (word_to_count & 0x0000FFFF) zeroes -= 16;
if (word_to_count & 0x00FF00FF) zeroes -= 8;
diff --git a/webrtc/base/ipaddress.h b/webrtc/base/ipaddress.h
index 0f32d3a..fe2d6e2 100644
--- a/webrtc/base/ipaddress.h
+++ b/webrtc/base/ipaddress.h
@@ -62,7 +62,7 @@
u_.ip6 = ip6;
}
- explicit IPAddress(uint32 ip_in_host_byte_order) : family_(AF_INET) {
+ explicit IPAddress(uint32_t ip_in_host_byte_order) : family_(AF_INET) {
memset(&u_, 0, sizeof(u_));
u_.ip4.s_addr = HostToNetwork32(ip_in_host_byte_order);
}
@@ -107,7 +107,7 @@
IPAddress AsIPv6Address() const;
// For socketaddress' benefit. Returns the IP in host byte order.
- uint32 v4AddressAsHostOrderInteger() const;
+ uint32_t v4AddressAsHostOrderInteger() const;
// Whether this is an unspecified IP address.
bool IsNil() const;
diff --git a/webrtc/base/logging.cc b/webrtc/base/logging.cc
index fd5e1cd..b60a244 100644
--- a/webrtc/base/logging.cc
+++ b/webrtc/base/logging.cc
@@ -118,7 +118,7 @@
tag_(kLibjingle),
warn_slow_logs_delay_(WARN_SLOW_LOGS_DELAY) {
if (timestamp_) {
- uint32 time = TimeSince(LogStartTime());
+ uint32_t time = TimeSince(LogStartTime());
// Also ensure WallClockStartTime is initialized, so that it matches
// LogStartTime.
WallClockStartTime();
@@ -197,7 +197,7 @@
OutputToDebug(str, severity_, tag_);
}
- uint32 before = Time();
+ uint32_t before = Time();
// Must lock streams_ before accessing
CritScope cs(&crit_);
for (StreamList::iterator it = streams_.begin(); it != streams_.end(); ++it) {
@@ -205,7 +205,7 @@
it->first->OnLogMessage(str);
}
}
- uint32 delay = TimeSince(before);
+ uint32_t delay = TimeSince(before);
if (delay >= warn_slow_logs_delay_) {
rtc::LogMessage slow_log_warning(__FILE__, __LINE__, LS_WARNING);
// If our warning is slow, we don't want to warn about it, because
@@ -217,13 +217,13 @@
}
}
-uint32 LogMessage::LogStartTime() {
- static const uint32 g_start = Time();
+uint32_t LogMessage::LogStartTime() {
+ static const uint32_t g_start = Time();
return g_start;
}
-uint32 LogMessage::WallClockStartTime() {
- static const uint32 g_start_wallclock = time(NULL);
+uint32_t LogMessage::WallClockStartTime() {
+ static const uint32_t g_start_wallclock = time(NULL);
return g_start_wallclock;
}
diff --git a/webrtc/base/logging.h b/webrtc/base/logging.h
index b8f460c..71c6c53 100644
--- a/webrtc/base/logging.h
+++ b/webrtc/base/logging.h
@@ -131,7 +131,7 @@
class LogMessage {
public:
- static const uint32 WARN_SLOW_LOGS_DELAY = 50; // ms
+ static const uint32_t WARN_SLOW_LOGS_DELAY = 50; // ms
LogMessage(const char* file, int line, LoggingSeverity sev,
LogErrorContext err_ctx = ERRCTX_NONE, int err = 0,
@@ -152,11 +152,11 @@
// If this is not called externally, the LogMessage ctor also calls it, in
// which case the logging start time will be the time of the first LogMessage
// instance is created.
- static uint32 LogStartTime();
+ static uint32_t LogStartTime();
// Returns the wall clock equivalent of |LogStartTime|, in seconds from the
// epoch.
- static uint32 WallClockStartTime();
+ static uint32_t WallClockStartTime();
// LogThreads: Display the thread identifier of the current thread
static void LogThreads(bool on = true);
@@ -218,7 +218,7 @@
// If time it takes to write to stream is more than this, log one
// additional warning about it.
- uint32 warn_slow_logs_delay_;
+ uint32_t warn_slow_logs_delay_;
// Global lock for the logging subsystem
static CriticalSection crit_;
diff --git a/webrtc/base/logging_unittest.cc b/webrtc/base/logging_unittest.cc
index 58ad6b7..3719cde 100644
--- a/webrtc/base/logging_unittest.cc
+++ b/webrtc/base/logging_unittest.cc
@@ -123,7 +123,7 @@
TEST(LogTest, WallClockStartTime) {
- uint32 time = LogMessage::WallClockStartTime();
+ uint32_t time = LogMessage::WallClockStartTime();
// Expect the time to be in a sensible range, e.g. > 2012-01-01.
EXPECT_GT(time, 1325376000u);
}
@@ -139,7 +139,7 @@
stream.DisableBuffering();
LogMessage::AddLogToStream(&stream, LS_SENSITIVE);
- uint32 start = Time(), finish;
+ uint32_t start = Time(), finish;
std::string message('X', 80);
for (int i = 0; i < 1000; ++i) {
LOG(LS_SENSITIVE) << message;
diff --git a/webrtc/base/macasyncsocket.cc b/webrtc/base/macasyncsocket.cc
index ee982ff..1f12500 100644
--- a/webrtc/base/macasyncsocket.cc
+++ b/webrtc/base/macasyncsocket.cc
@@ -276,7 +276,7 @@
return 0;
}
-int MacAsyncSocket::EstimateMTU(uint16* mtu) {
+int MacAsyncSocket::EstimateMTU(uint16_t* mtu) {
ASSERT(false && "NYI");
return -1;
}
diff --git a/webrtc/base/macasyncsocket.h b/webrtc/base/macasyncsocket.h
index 7351474..5861ee3 100644
--- a/webrtc/base/macasyncsocket.h
+++ b/webrtc/base/macasyncsocket.h
@@ -49,7 +49,7 @@
int GetError() const override;
void SetError(int error) override;
ConnState GetState() const override;
- int EstimateMTU(uint16* mtu) override;
+ int EstimateMTU(uint16_t* mtu) override;
int GetOption(Option opt, int* value) override;
int SetOption(Option opt, int value) override;
diff --git a/webrtc/base/maccocoasocketserver_unittest.mm b/webrtc/base/maccocoasocketserver_unittest.mm
index 932b4a1..5401ffb 100644
--- a/webrtc/base/maccocoasocketserver_unittest.mm
+++ b/webrtc/base/maccocoasocketserver_unittest.mm
@@ -32,7 +32,7 @@
// Test that MacCocoaSocketServer::Wait works as expected.
TEST(MacCocoaSocketServer, TestWait) {
MacCocoaSocketServer server;
- uint32 start = Time();
+ uint32_t start = Time();
server.Wait(1000, true);
EXPECT_GE(TimeSince(start), 1000);
}
@@ -41,7 +41,7 @@
TEST(MacCocoaSocketServer, TestWakeup) {
MacCFSocketServer server;
WakeThread thread(&server);
- uint32 start = Time();
+ uint32_t start = Time();
thread.Start();
server.Wait(10000, true);
EXPECT_LT(TimeSince(start), 10000);
diff --git a/webrtc/base/macsocketserver_unittest.cc b/webrtc/base/macsocketserver_unittest.cc
index 97732d7..ecb9a706 100644
--- a/webrtc/base/macsocketserver_unittest.cc
+++ b/webrtc/base/macsocketserver_unittest.cc
@@ -35,7 +35,7 @@
// Test that MacCFSocketServer::Wait works as expected.
TEST(MacCFSocketServerTest, TestWait) {
MacCFSocketServer server;
- uint32 start = Time();
+ uint32_t start = Time();
server.Wait(1000, true);
EXPECT_GE(TimeSince(start), 1000);
}
@@ -44,7 +44,7 @@
TEST(MacCFSocketServerTest, TestWakeup) {
MacCFSocketServer server;
WakeThread thread(&server);
- uint32 start = Time();
+ uint32_t start = Time();
thread.Start();
server.Wait(10000, true);
EXPECT_LT(TimeSince(start), 10000);
@@ -53,7 +53,7 @@
// Test that MacCarbonSocketServer::Wait works as expected.
TEST(MacCarbonSocketServerTest, TestWait) {
MacCarbonSocketServer server;
- uint32 start = Time();
+ uint32_t start = Time();
server.Wait(1000, true);
EXPECT_GE(TimeSince(start), 1000);
}
@@ -62,7 +62,7 @@
TEST(MacCarbonSocketServerTest, TestWakeup) {
MacCarbonSocketServer server;
WakeThread thread(&server);
- uint32 start = Time();
+ uint32_t start = Time();
thread.Start();
server.Wait(10000, true);
EXPECT_LT(TimeSince(start), 10000);
@@ -71,7 +71,7 @@
// Test that MacCarbonAppSocketServer::Wait works as expected.
TEST(MacCarbonAppSocketServerTest, TestWait) {
MacCarbonAppSocketServer server;
- uint32 start = Time();
+ uint32_t start = Time();
server.Wait(1000, true);
EXPECT_GE(TimeSince(start), 1000);
}
@@ -80,7 +80,7 @@
TEST(MacCarbonAppSocketServerTest, TestWakeup) {
MacCarbonAppSocketServer server;
WakeThread thread(&server);
- uint32 start = Time();
+ uint32_t start = Time();
thread.Start();
server.Wait(10000, true);
EXPECT_LT(TimeSince(start), 10000);
diff --git a/webrtc/base/md5.cc b/webrtc/base/md5.cc
index 6d47b60..fda6ddd 100644
--- a/webrtc/base/md5.cc
+++ b/webrtc/base/md5.cc
@@ -30,7 +30,7 @@
#ifdef RTC_ARCH_CPU_LITTLE_ENDIAN
#define ByteReverse(buf, len) // Nothing.
#else // RTC_ARCH_CPU_BIG_ENDIAN
-static void ByteReverse(uint32* buf, int len) {
+static void ByteReverse(uint32_t* buf, int len) {
for (int i = 0; i < len; ++i) {
buf[i] = rtc::GetLE32(&buf[i]);
}
@@ -49,18 +49,18 @@
}
// Update context to reflect the concatenation of another buffer full of bytes.
-void MD5Update(MD5Context* ctx, const uint8* buf, size_t len) {
+void MD5Update(MD5Context* ctx, const uint8_t* buf, size_t len) {
// Update bitcount.
- uint32 t = ctx->bits[0];
- if ((ctx->bits[0] = t + (static_cast<uint32>(len) << 3)) < t) {
+ uint32_t t = ctx->bits[0];
+ if ((ctx->bits[0] = t + (static_cast<uint32_t>(len) << 3)) < t) {
ctx->bits[1]++; // Carry from low to high.
}
- ctx->bits[1] += static_cast<uint32>(len >> 29);
+ ctx->bits[1] += static_cast<uint32_t>(len >> 29);
t = (t >> 3) & 0x3f; // Bytes already in shsInfo->data.
// Handle any leading odd-sized chunks.
if (t) {
- uint8* p = reinterpret_cast<uint8*>(ctx->in) + t;
+ uint8_t* p = reinterpret_cast<uint8_t*>(ctx->in) + t;
t = 64-t;
if (len < t) {
@@ -89,13 +89,13 @@
// Final wrapup - pad to 64-byte boundary with the bit pattern.
// 1 0* (64-bit count of bits processed, MSB-first)
-void MD5Final(MD5Context* ctx, uint8 digest[16]) {
+void MD5Final(MD5Context* ctx, uint8_t digest[16]) {
// Compute number of bytes mod 64.
- uint32 count = (ctx->bits[0] >> 3) & 0x3F;
+ uint32_t count = (ctx->bits[0] >> 3) & 0x3F;
// Set the first char of padding to 0x80. This is safe since there is
// always at least one byte free.
- uint8* p = reinterpret_cast<uint8*>(ctx->in) + count;
+ uint8_t* p = reinterpret_cast<uint8_t*>(ctx->in) + count;
*p++ = 0x80;
// Bytes of padding needed to make 64 bytes.
@@ -140,11 +140,11 @@
// The core of the MD5 algorithm, this alters an existing MD5 hash to
// reflect the addition of 16 longwords of new data. MD5Update blocks
// the data and converts bytes into longwords for this routine.
-void MD5Transform(uint32 buf[4], const uint32 in[16]) {
- uint32 a = buf[0];
- uint32 b = buf[1];
- uint32 c = buf[2];
- uint32 d = buf[3];
+void MD5Transform(uint32_t buf[4], const uint32_t in[16]) {
+ uint32_t a = buf[0];
+ uint32_t b = buf[1];
+ uint32_t c = buf[2];
+ uint32_t d = buf[3];
MD5STEP(F1, a, b, c, d, in[ 0] + 0xd76aa478, 7);
MD5STEP(F1, d, a, b, c, in[ 1] + 0xe8c7b756, 12);
diff --git a/webrtc/base/md5.h b/webrtc/base/md5.h
index 80294bb..45e00b7 100644
--- a/webrtc/base/md5.h
+++ b/webrtc/base/md5.h
@@ -18,24 +18,26 @@
// Changes(fbarchard): Ported to C++ and Google style guide.
// Made context first parameter in MD5Final for consistency with Sha1.
// Changes(hellner): added rtc namespace
+// Changes(pbos): Reverted types back to uint32(8)_t with _t suffix.
#ifndef WEBRTC_BASE_MD5_H_
#define WEBRTC_BASE_MD5_H_
-#include "webrtc/base/basictypes.h"
+#include <stdint.h>
+#include <stdlib.h>
namespace rtc {
struct MD5Context {
- uint32 buf[4];
- uint32 bits[2];
- uint32 in[16];
+ uint32_t buf[4];
+ uint32_t bits[2];
+ uint32_t in[16];
};
void MD5Init(MD5Context* context);
-void MD5Update(MD5Context* context, const uint8* data, size_t len);
-void MD5Final(MD5Context* context, uint8 digest[16]);
-void MD5Transform(uint32 buf[4], const uint32 in[16]);
+void MD5Update(MD5Context* context, const uint8_t* data, size_t len);
+void MD5Final(MD5Context* context, uint8_t digest[16]);
+void MD5Transform(uint32_t buf[4], const uint32_t in[16]);
} // namespace rtc
diff --git a/webrtc/base/md5digest.cc b/webrtc/base/md5digest.cc
index 1d014c3..74f6bed 100644
--- a/webrtc/base/md5digest.cc
+++ b/webrtc/base/md5digest.cc
@@ -17,14 +17,14 @@
}
void Md5Digest::Update(const void* buf, size_t len) {
- MD5Update(&ctx_, static_cast<const uint8*>(buf), len);
+ MD5Update(&ctx_, static_cast<const uint8_t*>(buf), len);
}
size_t Md5Digest::Finish(void* buf, size_t len) {
if (len < kSize) {
return 0;
}
- MD5Final(&ctx_, static_cast<uint8*>(buf));
+ MD5Final(&ctx_, static_cast<uint8_t*>(buf));
MD5Init(&ctx_); // Reset for next use.
return kSize;
}
diff --git a/webrtc/base/messagedigest.cc b/webrtc/base/messagedigest.cc
index 8af60d9..0c2b4a1 100644
--- a/webrtc/base/messagedigest.cc
+++ b/webrtc/base/messagedigest.cc
@@ -117,7 +117,7 @@
}
// Copy the key to a block-sized buffer to simplify padding.
// If the key is longer than a block, hash it and use the result instead.
- scoped_ptr<uint8[]> new_key(new uint8[block_len]);
+ scoped_ptr<uint8_t[]> new_key(new uint8_t[block_len]);
if (key_len > block_len) {
ComputeDigest(digest, key, key_len, new_key.get(), block_len);
memset(new_key.get() + digest->Size(), 0, block_len - digest->Size());
@@ -126,13 +126,14 @@
memset(new_key.get() + key_len, 0, block_len - key_len);
}
// Set up the padding from the key, salting appropriately for each padding.
- scoped_ptr<uint8[]> o_pad(new uint8[block_len]), i_pad(new uint8[block_len]);
+ scoped_ptr<uint8_t[]> o_pad(new uint8_t[block_len]);
+ scoped_ptr<uint8_t[]> i_pad(new uint8_t[block_len]);
for (size_t i = 0; i < block_len; ++i) {
o_pad[i] = 0x5c ^ new_key[i];
i_pad[i] = 0x36 ^ new_key[i];
}
// Inner hash; hash the inner padding, and then the input buffer.
- scoped_ptr<uint8[]> inner(new uint8[digest->Size()]);
+ scoped_ptr<uint8_t[]> inner(new uint8_t[digest->Size()]);
digest->Update(i_pad.get(), block_len);
digest->Update(input, in_len);
digest->Finish(inner.get(), digest->Size());
diff --git a/webrtc/base/messagequeue.cc b/webrtc/base/messagequeue.cc
index 5cf448e..857cf12 100644
--- a/webrtc/base/messagequeue.cc
+++ b/webrtc/base/messagequeue.cc
@@ -27,7 +27,7 @@
namespace rtc {
-const uint32 kMaxMsgLatency = 150; // 150 ms
+const uint32_t kMaxMsgLatency = 150; // 150 ms
//------------------------------------------------------------------
// MessageQueueManager
@@ -188,8 +188,8 @@
int cmsTotal = cmsWait;
int cmsElapsed = 0;
- uint32 msStart = Time();
- uint32 msCurrent = msStart;
+ uint32_t msStart = Time();
+ uint32_t msCurrent = msStart;
while (true) {
// Check for sent messages
ReceiveSends();
@@ -227,7 +227,7 @@
// Log a warning for time-sensitive messages that we're late to deliver.
if (pmsg->ts_sensitive) {
- int32 delay = TimeDiff(msCurrent, pmsg->ts_sensitive);
+ int32_t delay = TimeDiff(msCurrent, pmsg->ts_sensitive);
if (delay > 0) {
LOG_F(LS_WARNING) << "id: " << pmsg->message_id << " delay: "
<< (delay + kMaxMsgLatency) << "ms";
@@ -276,8 +276,10 @@
void MessageQueue::ReceiveSends() {
}
-void MessageQueue::Post(MessageHandler *phandler, uint32 id,
- MessageData *pdata, bool time_sensitive) {
+void MessageQueue::Post(MessageHandler* phandler,
+ uint32_t id,
+ MessageData* pdata,
+ bool time_sensitive) {
if (fStop_)
return;
@@ -299,20 +301,23 @@
void MessageQueue::PostDelayed(int cmsDelay,
MessageHandler* phandler,
- uint32 id,
+ uint32_t id,
MessageData* pdata) {
return DoDelayPost(cmsDelay, TimeAfter(cmsDelay), phandler, id, pdata);
}
-void MessageQueue::PostAt(uint32 tstamp,
+void MessageQueue::PostAt(uint32_t tstamp,
MessageHandler* phandler,
- uint32 id,
+ uint32_t id,
MessageData* pdata) {
return DoDelayPost(TimeUntil(tstamp), tstamp, phandler, id, pdata);
}
-void MessageQueue::DoDelayPost(int cmsDelay, uint32 tstamp,
- MessageHandler *phandler, uint32 id, MessageData* pdata) {
+void MessageQueue::DoDelayPost(int cmsDelay,
+ uint32_t tstamp,
+ MessageHandler* phandler,
+ uint32_t id,
+ MessageData* pdata) {
if (fStop_)
return;
@@ -350,7 +355,8 @@
return kForever;
}
-void MessageQueue::Clear(MessageHandler *phandler, uint32 id,
+void MessageQueue::Clear(MessageHandler* phandler,
+ uint32_t id,
MessageList* removed) {
CritScope cs(&crit_);
diff --git a/webrtc/base/messagequeue.h b/webrtc/base/messagequeue.h
index 23dbafc..c3ab3b6 100644
--- a/webrtc/base/messagequeue.h
+++ b/webrtc/base/messagequeue.h
@@ -123,8 +123,8 @@
T* data_;
};
-const uint32 MQID_ANY = static_cast<uint32>(-1);
-const uint32 MQID_DISPOSE = static_cast<uint32>(-2);
+const uint32_t MQID_ANY = static_cast<uint32_t>(-1);
+const uint32_t MQID_DISPOSE = static_cast<uint32_t>(-2);
// No destructor
@@ -132,14 +132,14 @@
Message() {
memset(this, 0, sizeof(*this));
}
- inline bool Match(MessageHandler* handler, uint32 id) const {
+ inline bool Match(MessageHandler* handler, uint32_t id) const {
return (handler == NULL || handler == phandler)
&& (id == MQID_ANY || id == message_id);
}
MessageHandler *phandler;
- uint32 message_id;
+ uint32_t message_id;
MessageData *pdata;
- uint32 ts_sensitive;
+ uint32_t ts_sensitive;
};
typedef std::list<Message> MessageList;
@@ -149,8 +149,8 @@
class DelayedMessage {
public:
- DelayedMessage(int delay, uint32 trigger, uint32 num, const Message& msg)
- : cmsDelay_(delay), msTrigger_(trigger), num_(num), msg_(msg) { }
+ DelayedMessage(int delay, uint32_t trigger, uint32_t num, const Message& msg)
+ : cmsDelay_(delay), msTrigger_(trigger), num_(num), msg_(msg) {}
bool operator< (const DelayedMessage& dmsg) const {
return (dmsg.msTrigger_ < msTrigger_)
@@ -158,8 +158,8 @@
}
int cmsDelay_; // for debugging
- uint32 msTrigger_;
- uint32 num_;
+ uint32_t msTrigger_;
+ uint32_t num_;
Message msg_;
};
@@ -190,17 +190,20 @@
virtual bool Get(Message *pmsg, int cmsWait = kForever,
bool process_io = true);
virtual bool Peek(Message *pmsg, int cmsWait = 0);
- virtual void Post(MessageHandler *phandler, uint32 id = 0,
- MessageData *pdata = NULL, bool time_sensitive = false);
+ virtual void Post(MessageHandler* phandler,
+ uint32_t id = 0,
+ MessageData* pdata = NULL,
+ bool time_sensitive = false);
virtual void PostDelayed(int cmsDelay,
MessageHandler* phandler,
- uint32 id = 0,
+ uint32_t id = 0,
MessageData* pdata = NULL);
- virtual void PostAt(uint32 tstamp,
+ virtual void PostAt(uint32_t tstamp,
MessageHandler* phandler,
- uint32 id = 0,
+ uint32_t id = 0,
MessageData* pdata = NULL);
- virtual void Clear(MessageHandler *phandler, uint32 id = MQID_ANY,
+ virtual void Clear(MessageHandler* phandler,
+ uint32_t id = MQID_ANY,
MessageList* removed = NULL);
virtual void Dispatch(Message *pmsg);
virtual void ReceiveSends();
@@ -232,8 +235,11 @@
void reheap() { make_heap(c.begin(), c.end(), comp); }
};
- void DoDelayPost(int cmsDelay, uint32 tstamp, MessageHandler *phandler,
- uint32 id, MessageData* pdata);
+ void DoDelayPost(int cmsDelay,
+ uint32_t tstamp,
+ MessageHandler* phandler,
+ uint32_t id,
+ MessageData* pdata);
// The SocketServer is not owned by MessageQueue.
SocketServer* ss_;
@@ -244,7 +250,7 @@
Message msgPeek_;
MessageList msgq_;
PriorityQueue dmsgq_;
- uint32 dmsgq_next_num_;
+ uint32_t dmsgq_next_num_;
mutable CriticalSection crit_;
private:
diff --git a/webrtc/base/natsocketfactory.cc b/webrtc/base/natsocketfactory.cc
index a23a7e8..548a80c 100644
--- a/webrtc/base/natsocketfactory.cc
+++ b/webrtc/base/natsocketfactory.cc
@@ -26,7 +26,7 @@
buf[0] = 0;
buf[1] = family;
// Writes the port.
- *(reinterpret_cast<uint16*>(&buf[2])) = HostToNetwork16(remote_addr.port());
+ *(reinterpret_cast<uint16_t*>(&buf[2])) = HostToNetwork16(remote_addr.port());
if (family == AF_INET) {
ASSERT(buf_size >= kNATEncodedIPv4AddressSize);
in_addr v4addr = ip.ipv4_address();
@@ -49,7 +49,8 @@
ASSERT(buf_size >= 8);
ASSERT(buf[0] == 0);
int family = buf[1];
- uint16 port = NetworkToHost16(*(reinterpret_cast<const uint16*>(&buf[2])));
+ uint16_t port =
+ NetworkToHost16(*(reinterpret_cast<const uint16_t*>(&buf[2])));
if (family == AF_INET) {
const in_addr* v4addr = reinterpret_cast<const in_addr*>(&buf[4]);
*remote_addr = SocketAddress(IPAddress(*v4addr), port);
@@ -220,7 +221,7 @@
ConnState GetState() const override {
return connected_ ? CS_CONNECTED : CS_CLOSED;
}
- int EstimateMTU(uint16* mtu) override { return socket_->EstimateMTU(mtu); }
+ int EstimateMTU(uint16_t* mtu) override { return socket_->EstimateMTU(mtu); }
int GetOption(Option opt, int* value) override {
return socket_->GetOption(opt, value);
}
diff --git a/webrtc/base/network.cc b/webrtc/base/network.cc
index bc7d505..bc714e3 100644
--- a/webrtc/base/network.cc
+++ b/webrtc/base/network.cc
@@ -62,8 +62,8 @@
// limit of IPv6 networks but could be changed by set_max_ipv6_networks().
const int kMaxIPv6Networks = 5;
-const uint32 kUpdateNetworksMessage = 1;
-const uint32 kSignalNetworksMessage = 2;
+const uint32_t kUpdateNetworksMessage = 1;
+const uint32_t kSignalNetworksMessage = 2;
// Fetch list of networks every two seconds.
const int kNetworksUpdateIntervalMs = 2000;
diff --git a/webrtc/base/nullsocketserver_unittest.cc b/webrtc/base/nullsocketserver_unittest.cc
index 4bb1d7f..2aa38b4 100644
--- a/webrtc/base/nullsocketserver_unittest.cc
+++ b/webrtc/base/nullsocketserver_unittest.cc
@@ -14,7 +14,7 @@
namespace rtc {
-static const uint32 kTimeout = 5000U;
+static const uint32_t kTimeout = 5000U;
class NullSocketServerTest
: public testing::Test,
@@ -38,7 +38,7 @@
}
TEST_F(NullSocketServerTest, TestWait) {
- uint32 start = Time();
+ uint32_t start = Time();
ss_.Wait(200, true);
// The actual wait time is dependent on the resolution of the timer used by
// the Event class. Allow for the event to signal ~20ms early.
diff --git a/webrtc/base/opensslstreamadapter.cc b/webrtc/base/opensslstreamadapter.cc
index c759ee5..67ed5db 100644
--- a/webrtc/base/opensslstreamadapter.cc
+++ b/webrtc/base/opensslstreamadapter.cc
@@ -384,17 +384,16 @@
// Key Extractor interface
bool OpenSSLStreamAdapter::ExportKeyingMaterial(const std::string& label,
- const uint8* context,
+ const uint8_t* context,
size_t context_len,
bool use_context,
- uint8* result,
+ uint8_t* result,
size_t result_len) {
#ifdef HAVE_DTLS_SRTP
int i;
- i = SSL_export_keying_material(ssl_, result, result_len,
- label.c_str(), label.length(),
- const_cast<uint8 *>(context),
+ i = SSL_export_keying_material(ssl_, result, result_len, label.c_str(),
+ label.length(), const_cast<uint8_t*>(context),
context_len, use_context);
if (i != 1)
diff --git a/webrtc/base/opensslstreamadapter.h b/webrtc/base/opensslstreamadapter.h
index 56bba41..0f3ded9 100644
--- a/webrtc/base/opensslstreamadapter.h
+++ b/webrtc/base/opensslstreamadapter.h
@@ -94,10 +94,10 @@
// Key Extractor interface
bool ExportKeyingMaterial(const std::string& label,
- const uint8* context,
+ const uint8_t* context,
size_t context_len,
bool use_context,
- uint8* result,
+ uint8_t* result,
size_t result_len) override;
// DTLS-SRTP interface
diff --git a/webrtc/base/pathutils.cc b/webrtc/base/pathutils.cc
index 7671bfc..b5227ec 100644
--- a/webrtc/base/pathutils.cc
+++ b/webrtc/base/pathutils.cc
@@ -225,12 +225,13 @@
}
#if defined(WEBRTC_WIN)
-bool Pathname::GetDrive(char *drive, uint32 bytes) const {
+bool Pathname::GetDrive(char* drive, uint32_t bytes) const {
return GetDrive(drive, bytes, folder_);
}
// static
-bool Pathname::GetDrive(char *drive, uint32 bytes,
+bool Pathname::GetDrive(char* drive,
+ uint32_t bytes,
const std::string& pathname) {
// need at lease 4 bytes to save c:
if (bytes < 4 || pathname.size() < 3) {
diff --git a/webrtc/base/pathutils.h b/webrtc/base/pathutils.h
index 8f07e1d..2d5819f 100644
--- a/webrtc/base/pathutils.h
+++ b/webrtc/base/pathutils.h
@@ -92,8 +92,10 @@
bool SetFilename(const std::string& filename);
#if defined(WEBRTC_WIN)
- bool GetDrive(char *drive, uint32 bytes) const;
- static bool GetDrive(char *drive, uint32 bytes,const std::string& pathname);
+ bool GetDrive(char* drive, uint32_t bytes) const;
+ static bool GetDrive(char* drive,
+ uint32_t bytes,
+ const std::string& pathname);
#endif
private:
diff --git a/webrtc/base/physicalsocketserver.cc b/webrtc/base/physicalsocketserver.cc
index b9c2a07..01f0731 100644
--- a/webrtc/base/physicalsocketserver.cc
+++ b/webrtc/base/physicalsocketserver.cc
@@ -68,26 +68,26 @@
#if defined(WEBRTC_WIN)
// Standard MTUs, from RFC 1191
-const uint16 PACKET_MAXIMUMS[] = {
- 65535, // Theoretical maximum, Hyperchannel
- 32000, // Nothing
- 17914, // 16Mb IBM Token Ring
- 8166, // IEEE 802.4
- //4464, // IEEE 802.5 (4Mb max)
- 4352, // FDDI
- //2048, // Wideband Network
- 2002, // IEEE 802.5 (4Mb recommended)
- //1536, // Expermental Ethernet Networks
- //1500, // Ethernet, Point-to-Point (default)
- 1492, // IEEE 802.3
- 1006, // SLIP, ARPANET
- //576, // X.25 Networks
- //544, // DEC IP Portal
- //512, // NETBIOS
- 508, // IEEE 802/Source-Rt Bridge, ARCNET
- 296, // Point-to-Point (low delay)
- 68, // Official minimum
- 0, // End of list marker
+const uint16_t PACKET_MAXIMUMS[] = {
+ 65535, // Theoretical maximum, Hyperchannel
+ 32000, // Nothing
+ 17914, // 16Mb IBM Token Ring
+ 8166, // IEEE 802.4
+ // 4464, // IEEE 802.5 (4Mb max)
+ 4352, // FDDI
+ // 2048, // Wideband Network
+ 2002, // IEEE 802.5 (4Mb recommended)
+ // 1536, // Expermental Ethernet Networks
+ // 1500, // Ethernet, Point-to-Point (default)
+ 1492, // IEEE 802.3
+ 1006, // SLIP, ARPANET
+ // 576, // X.25 Networks
+ // 544, // DEC IP Portal
+ // 512, // NETBIOS
+ 508, // IEEE 802/Source-Rt Bridge, ARCNET
+ 296, // Point-to-Point (low delay)
+ 68, // Official minimum
+ 0, // End of list marker
};
static const int IP_HEADER_SIZE = 20u;
@@ -398,7 +398,7 @@
return err;
}
- int EstimateMTU(uint16* mtu) override {
+ int EstimateMTU(uint16_t* mtu) override {
SocketAddress addr = GetRemoteAddress();
if (addr.IsAny()) {
SetError(ENOTCONN);
@@ -420,7 +420,7 @@
}
for (int level = 0; PACKET_MAXIMUMS[level + 1] > 0; ++level) {
- int32 size = PACKET_MAXIMUMS[level] - header_size;
+ int32_t size = PACKET_MAXIMUMS[level] - header_size;
WinPing::PingResult result = ping.Ping(addr.ipaddr(), size,
ICMP_PING_TIMEOUT_MILLIS,
1, false);
@@ -541,7 +541,7 @@
PhysicalSocketServer* ss_;
SOCKET s_;
- uint8 enabled_events_;
+ uint8_t enabled_events_;
bool udp_;
int error_;
// Protects |error_| that is accessed from different threads.
@@ -572,28 +572,28 @@
virtual void Signal() {
CritScope cs(&crit_);
if (!fSignaled_) {
- const uint8 b[1] = { 0 };
+ const uint8_t b[1] = {0};
if (VERIFY(1 == write(afd_[1], b, sizeof(b)))) {
fSignaled_ = true;
}
}
}
- uint32 GetRequestedEvents() override { return DE_READ; }
+ uint32_t GetRequestedEvents() override { return DE_READ; }
- void OnPreEvent(uint32 ff) override {
+ void OnPreEvent(uint32_t ff) override {
// It is not possible to perfectly emulate an auto-resetting event with
// pipes. This simulates it by resetting before the event is handled.
CritScope cs(&crit_);
if (fSignaled_) {
- uint8 b[4]; // Allow for reading more than 1 byte, but expect 1.
+ uint8_t b[4]; // Allow for reading more than 1 byte, but expect 1.
VERIFY(1 == read(afd_[0], b, sizeof(b)));
fSignaled_ = false;
}
}
- void OnEvent(uint32 ff, int err) override { ASSERT(false); }
+ void OnEvent(uint32_t ff, int err) override { ASSERT(false); }
int GetDescriptor() override { return afd_[0]; }
@@ -661,7 +661,7 @@
// Set a flag saying we've seen this signal.
received_signal_[signum] = true;
// Notify application code that we got a signal.
- const uint8 b[1] = { 0 };
+ const uint8_t b[1] = {0};
if (-1 == write(afd_[1], b, sizeof(b))) {
// Nothing we can do here. If there's an error somehow then there's
// nothing we can safely do from a signal handler.
@@ -718,7 +718,7 @@
// will still be handled, so this isn't a problem.
// Volatile is not necessary here for correctness, but this data _is_ volatile
// so I've marked it as such.
- volatile uint8 received_signal_[kNumPosixSignals];
+ volatile uint8_t received_signal_[kNumPosixSignals];
};
class PosixSignalDispatcher : public Dispatcher {
@@ -731,12 +731,12 @@
owner_->Remove(this);
}
- uint32 GetRequestedEvents() override { return DE_READ; }
+ uint32_t GetRequestedEvents() override { return DE_READ; }
- void OnPreEvent(uint32 ff) override {
+ void OnPreEvent(uint32_t ff) override {
// Events might get grouped if signals come very fast, so we read out up to
// 16 bytes to make sure we keep the pipe empty.
- uint8 b[16];
+ uint8_t b[16];
ssize_t ret = read(GetDescriptor(), b, sizeof(b));
if (ret < 0) {
LOG_ERR(LS_WARNING) << "Error in read()";
@@ -745,7 +745,7 @@
}
}
- void OnEvent(uint32 ff, int err) override {
+ void OnEvent(uint32_t ff, int err) override {
for (int signum = 0; signum < PosixSignalHandler::kNumPosixSignals;
++signum) {
if (PosixSignalHandler::Instance()->IsSignalSet(signum)) {
@@ -856,16 +856,16 @@
}
}
- uint32 GetRequestedEvents() override { return enabled_events_; }
+ uint32_t GetRequestedEvents() override { return enabled_events_; }
- void OnPreEvent(uint32 ff) override {
+ void OnPreEvent(uint32_t ff) override {
if ((ff & DE_CONNECT) != 0)
state_ = CS_CONNECTED;
if ((ff & DE_CLOSE) != 0)
state_ = CS_CLOSED;
}
- void OnEvent(uint32 ff, int err) override {
+ void OnEvent(uint32_t ff, int err) override {
// Make sure we deliver connect/accept first. Otherwise, consumers may see
// something like a READ followed by a CONNECT, which would be odd.
if ((ff & DE_CONNECT) != 0) {
@@ -920,11 +920,11 @@
bool IsDescriptorClosed() override { return false; }
- uint32 GetRequestedEvents() override { return flags_; }
+ uint32_t GetRequestedEvents() override { return flags_; }
- void OnPreEvent(uint32 ff) override {}
+ void OnPreEvent(uint32_t ff) override {}
- void OnEvent(uint32 ff, int err) override {
+ void OnEvent(uint32_t ff, int err) override {
if ((ff & DE_READ) != 0)
SignalReadEvent(this);
if ((ff & DE_WRITE) != 0)
@@ -958,8 +958,8 @@
#endif // WEBRTC_POSIX
#if defined(WEBRTC_WIN)
-static uint32 FlagsToEvents(uint32 events) {
- uint32 ffFD = FD_CLOSE;
+static uint32_t FlagsToEvents(uint32_t events) {
+ uint32_t ffFD = FD_CLOSE;
if (events & DE_READ)
ffFD |= FD_READ;
if (events & DE_WRITE)
@@ -993,16 +993,11 @@
WSASetEvent(hev_);
}
- virtual uint32 GetRequestedEvents() {
- return 0;
- }
+ virtual uint32_t GetRequestedEvents() { return 0; }
- virtual void OnPreEvent(uint32 ff) {
- WSAResetEvent(hev_);
- }
+ virtual void OnPreEvent(uint32_t ff) { WSAResetEvent(hev_); }
- virtual void OnEvent(uint32 ff, int err) {
- }
+ virtual void OnEvent(uint32_t ff, int err) {}
virtual WSAEVENT GetWSAEvent() {
return hev_;
@@ -1077,17 +1072,15 @@
return PhysicalSocket::Close();
}
- virtual uint32 GetRequestedEvents() {
- return enabled_events_;
- }
+ virtual uint32_t GetRequestedEvents() { return enabled_events_; }
- virtual void OnPreEvent(uint32 ff) {
+ virtual void OnPreEvent(uint32_t ff) {
if ((ff & DE_CONNECT) != 0)
state_ = CS_CONNECTED;
// We set CS_CLOSED from CheckSignalClose.
}
- virtual void OnEvent(uint32 ff, int err) {
+ virtual void OnEvent(uint32_t ff, int err) {
int cache_id = id_;
// Make sure we deliver connect/accept first. Otherwise, consumers may see
// something like a READ followed by a CONNECT, which would be odd.
@@ -1154,7 +1147,7 @@
}
~Signaler() override { }
- void OnEvent(uint32 ff, int err) override {
+ void OnEvent(uint32_t ff, int err) override {
if (pf_)
*pf_ = false;
}
@@ -1312,7 +1305,7 @@
if (fd > fdmax)
fdmax = fd;
- uint32 ff = pdispatcher->GetRequestedEvents();
+ uint32_t ff = pdispatcher->GetRequestedEvents();
if (ff & (DE_READ | DE_ACCEPT))
FD_SET(fd, &fdsRead);
if (ff & (DE_WRITE | DE_CONNECT))
@@ -1345,7 +1338,7 @@
for (size_t i = 0; i < dispatchers_.size(); ++i) {
Dispatcher *pdispatcher = dispatchers_[i];
int fd = pdispatcher->GetDescriptor();
- uint32 ff = 0;
+ uint32_t ff = 0;
int errcode = 0;
// Reap any error code, which can be signaled through reads or writes.
@@ -1479,7 +1472,7 @@
bool PhysicalSocketServer::Wait(int cmsWait, bool process_io) {
int cmsTotal = cmsWait;
int cmsElapsed = 0;
- uint32 msStart = Time();
+ uint32_t msStart = Time();
fWait_ = true;
while (fWait_) {
@@ -1590,7 +1583,7 @@
}
}
#endif
- uint32 ff = 0;
+ uint32_t ff = 0;
int errcode = 0;
if (wsaEvents.lNetworkEvents & FD_READ)
ff |= DE_READ;
diff --git a/webrtc/base/physicalsocketserver.h b/webrtc/base/physicalsocketserver.h
index 15be789..af09e0b 100644
--- a/webrtc/base/physicalsocketserver.h
+++ b/webrtc/base/physicalsocketserver.h
@@ -41,9 +41,9 @@
class Dispatcher {
public:
virtual ~Dispatcher() {}
- virtual uint32 GetRequestedEvents() = 0;
- virtual void OnPreEvent(uint32 ff) = 0;
- virtual void OnEvent(uint32 ff, int err) = 0;
+ virtual uint32_t GetRequestedEvents() = 0;
+ virtual void OnPreEvent(uint32_t ff) = 0;
+ virtual void OnEvent(uint32_t ff, int err) = 0;
#if defined(WEBRTC_WIN)
virtual WSAEVENT GetWSAEvent() = 0;
virtual SOCKET GetSocket() = 0;
diff --git a/webrtc/base/profiler.cc b/webrtc/base/profiler.cc
index 9f781fb..873b198 100644
--- a/webrtc/base/profiler.cc
+++ b/webrtc/base/profiler.cc
@@ -55,7 +55,7 @@
++start_count_;
}
-void ProfilerEvent::Stop(uint64 stop_time) {
+void ProfilerEvent::Stop(uint64_t stop_time) {
--start_count_;
ASSERT(start_count_ >= 0);
if (start_count_ == 0) {
@@ -114,7 +114,7 @@
void Profiler::StopEvent(const std::string& event_name) {
// Get the time ASAP, then wait for the lock.
- uint64 stop_time = TimeNanos();
+ uint64_t stop_time = TimeNanos();
SharedScope scope(&lock_);
EventMap::iterator it = events_.find(event_name);
if (it != events_.end()) {
diff --git a/webrtc/base/profiler.h b/webrtc/base/profiler.h
index 68a35b2..419763f 100644
--- a/webrtc/base/profiler.h
+++ b/webrtc/base/profiler.h
@@ -91,7 +91,7 @@
ProfilerEvent();
void Start();
void Stop();
- void Stop(uint64 stop_time);
+ void Stop(uint64_t stop_time);
double standard_deviation() const;
double total_time() const { return total_time_; }
double mean() const { return mean_; }
@@ -101,7 +101,7 @@
bool is_started() const { return start_count_ > 0; }
private:
- uint64 current_start_time_;
+ uint64_t current_start_time_;
double total_time_;
double mean_;
double sum_of_squared_differences_;
diff --git a/webrtc/base/proxydetect.cc b/webrtc/base/proxydetect.cc
index 16bf822..b144d20 100644
--- a/webrtc/base/proxydetect.cc
+++ b/webrtc/base/proxydetect.cc
@@ -213,13 +213,13 @@
int a, b, c, d, m;
int match = sscanf(item, "%d.%d.%d.%d/%d", &a, &b, &c, &d, &m);
if (match >= 4) {
- uint32 ip = ((a & 0xFF) << 24) | ((b & 0xFF) << 16) | ((c & 0xFF) << 8) |
- (d & 0xFF);
+ uint32_t ip = ((a & 0xFF) << 24) | ((b & 0xFF) << 16) | ((c & 0xFF) << 8) |
+ (d & 0xFF);
if ((match < 5) || (m > 32))
m = 32;
else if (m < 0)
m = 0;
- uint32 mask = (m == 0) ? 0 : (~0UL) << (32 - m);
+ uint32_t mask = (m == 0) ? 0 : (~0UL) << (32 - m);
SocketAddress addr(url.host(), 0);
// TODO: Support IPv6 proxyitems. This code block is IPv4 only anyway.
return !addr.IsUnresolved() &&
@@ -289,7 +289,7 @@
ProxyType ptype;
std::string host;
- uint16 port;
+ uint16_t port;
const char* address = saddress.c_str();
while (*address) {
@@ -323,7 +323,7 @@
*colon = 0;
char * endptr;
- port = static_cast<uint16>(strtol(colon + 1, &endptr, 0));
+ port = static_cast<uint16_t>(strtol(colon + 1, &endptr, 0));
if (*endptr != 0) {
LOG(LS_WARNING) << "Proxy address with invalid port [" << buffer << "]";
continue;
@@ -397,7 +397,7 @@
return false;
}
char buffer[NAME_MAX + 1];
- if (0 != FSRefMakePath(&fr, reinterpret_cast<uint8*>(buffer),
+ if (0 != FSRefMakePath(&fr, reinterpret_cast<uint8_t*>(buffer),
ARRAY_SIZE(buffer))) {
LOG(LS_ERROR) << "FSRefMakePath failed";
return false;
diff --git a/webrtc/base/ratetracker.cc b/webrtc/base/ratetracker.cc
index 57906f7..5cb44901 100644
--- a/webrtc/base/ratetracker.cc
+++ b/webrtc/base/ratetracker.cc
@@ -19,13 +19,12 @@
namespace rtc {
-RateTracker::RateTracker(
- uint32 bucket_milliseconds, size_t bucket_count)
+RateTracker::RateTracker(uint32_t bucket_milliseconds, size_t bucket_count)
: bucket_milliseconds_(bucket_milliseconds),
- bucket_count_(bucket_count),
- sample_buckets_(new size_t[bucket_count + 1]),
- total_sample_count_(0u),
- bucket_start_time_milliseconds_(~0u) {
+ bucket_count_(bucket_count),
+ sample_buckets_(new size_t[bucket_count + 1]),
+ total_sample_count_(0u),
+ bucket_start_time_milliseconds_(~0u) {
RTC_CHECK(bucket_milliseconds > 0u);
RTC_CHECK(bucket_count > 0u);
}
@@ -35,26 +34,27 @@
}
double RateTracker::ComputeRateForInterval(
- uint32 interval_milliseconds) const {
+ uint32_t interval_milliseconds) const {
if (bucket_start_time_milliseconds_ == ~0u) {
return 0.0;
}
- uint32 current_time = Time();
+ uint32_t current_time = Time();
// Calculate which buckets to sum up given the current time. If the time
// has passed to a new bucket then we have to skip some of the oldest buckets.
- uint32 available_interval_milliseconds = std::min<uint32>(
+ uint32_t available_interval_milliseconds = std::min<uint32_t>(
interval_milliseconds,
- bucket_milliseconds_ * static_cast<uint32>(bucket_count_));
+ bucket_milliseconds_ * static_cast<uint32_t>(bucket_count_));
// number of old buckets (i.e. after the current bucket in the ring buffer)
// that are expired given our current time interval.
size_t buckets_to_skip;
// Number of milliseconds of the first bucket that are not a portion of the
// current interval.
- uint32 milliseconds_to_skip;
+ uint32_t milliseconds_to_skip;
if (current_time >
initialization_time_milliseconds_ + available_interval_milliseconds) {
- uint32 time_to_skip = current_time - bucket_start_time_milliseconds_ +
- static_cast<uint32>(bucket_count_) * bucket_milliseconds_ -
+ uint32_t time_to_skip =
+ current_time - bucket_start_time_milliseconds_ +
+ static_cast<uint32_t>(bucket_count_) * bucket_milliseconds_ -
available_interval_milliseconds;
buckets_to_skip = time_to_skip / bucket_milliseconds_;
milliseconds_to_skip = time_to_skip % bucket_milliseconds_;
@@ -91,7 +91,7 @@
if (bucket_start_time_milliseconds_ == ~0u) {
return 0.0;
}
- uint32 current_time = Time();
+ uint32_t current_time = Time();
if (TimeIsLaterOrEqual(current_time, initialization_time_milliseconds_)) {
return 0.0;
}
@@ -106,7 +106,7 @@
void RateTracker::AddSamples(size_t sample_count) {
EnsureInitialized();
- uint32 current_time = Time();
+ uint32_t current_time = Time();
// Advance the current bucket as needed for the current time, and reset
// bucket counts as we advance.
for (size_t i = 0u; i <= bucket_count_ &&
@@ -125,7 +125,7 @@
total_sample_count_ += sample_count;
}
-uint32 RateTracker::Time() const {
+uint32_t RateTracker::Time() const {
return rtc::Time();
}
diff --git a/webrtc/base/ratetracker.h b/webrtc/base/ratetracker.h
index 0e2e040..d49d7ca 100644
--- a/webrtc/base/ratetracker.h
+++ b/webrtc/base/ratetracker.h
@@ -21,19 +21,19 @@
// that over each bucket the rate was constant.
class RateTracker {
public:
- RateTracker(uint32 bucket_milliseconds, size_t bucket_count);
+ RateTracker(uint32_t bucket_milliseconds, size_t bucket_count);
virtual ~RateTracker();
// Computes the average rate over the most recent interval_milliseconds,
// or if the first sample was added within this period, computes the rate
// since the first sample was added.
- double ComputeRateForInterval(uint32 interval_milliseconds) const;
+ double ComputeRateForInterval(uint32_t interval_milliseconds) const;
// Computes the average rate over the rate tracker's recording interval
// of bucket_milliseconds * bucket_count.
double ComputeRate() const {
- return ComputeRateForInterval(
- bucket_milliseconds_ * static_cast<uint32>(bucket_count_));
+ return ComputeRateForInterval(bucket_milliseconds_ *
+ static_cast<uint32_t>(bucket_count_));
}
// Computes the average rate since the first sample was added to the
@@ -49,19 +49,19 @@
protected:
// overrideable for tests
- virtual uint32 Time() const;
+ virtual uint32_t Time() const;
private:
void EnsureInitialized();
size_t NextBucketIndex(size_t bucket_index) const;
- const uint32 bucket_milliseconds_;
+ const uint32_t bucket_milliseconds_;
const size_t bucket_count_;
size_t* sample_buckets_;
size_t total_sample_count_;
size_t current_bucket_;
- uint32 bucket_start_time_milliseconds_;
- uint32 initialization_time_milliseconds_;
+ uint32_t bucket_start_time_milliseconds_;
+ uint32_t initialization_time_milliseconds_;
};
} // namespace rtc
diff --git a/webrtc/base/ratetracker_unittest.cc b/webrtc/base/ratetracker_unittest.cc
index 043f537..2187282 100644
--- a/webrtc/base/ratetracker_unittest.cc
+++ b/webrtc/base/ratetracker_unittest.cc
@@ -16,11 +16,11 @@
class RateTrackerForTest : public RateTracker {
public:
RateTrackerForTest() : RateTracker(100u, 10u), time_(0) {}
- virtual uint32 Time() const { return time_; }
- void AdvanceTime(uint32 delta) { time_ += delta; }
+ virtual uint32_t Time() const { return time_; }
+ void AdvanceTime(uint32_t delta) { time_ += delta; }
private:
- uint32 time_;
+ uint32_t time_;
};
TEST(RateTrackerTest, Test30FPS) {
diff --git a/webrtc/base/rtccertificate.cc b/webrtc/base/rtccertificate.cc
index d912eb4..a176d90 100644
--- a/webrtc/base/rtccertificate.cc
+++ b/webrtc/base/rtccertificate.cc
@@ -28,7 +28,7 @@
RTCCertificate::~RTCCertificate() {
}
-uint64 RTCCertificate::expires_timestamp_ns() const {
+uint64_t RTCCertificate::expires_timestamp_ns() const {
// TODO(hbos): Update once SSLIdentity/SSLCertificate supports expires field.
return 0;
}
diff --git a/webrtc/base/rtccertificate.h b/webrtc/base/rtccertificate.h
index cb68355..d238938 100644
--- a/webrtc/base/rtccertificate.h
+++ b/webrtc/base/rtccertificate.h
@@ -27,7 +27,7 @@
// Takes ownership of |identity|.
static scoped_refptr<RTCCertificate> Create(scoped_ptr<SSLIdentity> identity);
- uint64 expires_timestamp_ns() const;
+ uint64_t expires_timestamp_ns() const;
bool HasExpired() const;
const SSLCertificate& ssl_certificate() const;
diff --git a/webrtc/base/sha1.cc b/webrtc/base/sha1.cc
index b2af313..5816152 100644
--- a/webrtc/base/sha1.cc
+++ b/webrtc/base/sha1.cc
@@ -96,6 +96,11 @@
* Modified 05/2015
* By Sergey Ulanov <sergeyu@chromium.org>
* Removed static buffer to make computation thread-safe.
+ *
+ * -----------------
+ * Modified 10/2015
+ * By Peter Boström <pbos@webrtc.org>
+ * Change uint32(8) back to uint32(8)_t (undoes (03/2012) change).
*/
// Enabling SHA1HANDSOFF preserves the caller's data buffer.
@@ -156,13 +161,13 @@
#endif /* VERBOSE */
// Hash a single 512-bit block. This is the core of the algorithm.
-void SHA1Transform(uint32 state[5], const uint8 buffer[64]) {
+void SHA1Transform(uint32_t state[5], const uint8_t buffer[64]) {
union CHAR64LONG16 {
- uint8 c[64];
- uint32 l[16];
+ uint8_t c[64];
+ uint32_t l[16];
};
#ifdef SHA1HANDSOFF
- uint8 workspace[64];
+ uint8_t workspace[64];
memcpy(workspace, buffer, 64);
CHAR64LONG16* block = reinterpret_cast<CHAR64LONG16*>(workspace);
#else
@@ -172,11 +177,11 @@
#endif
// Copy context->state[] to working vars.
- uint32 a = state[0];
- uint32 b = state[1];
- uint32 c = state[2];
- uint32 d = state[3];
- uint32 e = state[4];
+ uint32_t a = state[0];
+ uint32_t b = state[1];
+ uint32_t c = state[2];
+ uint32_t d = state[3];
+ uint32_t e = state[4];
// 4 rounds of 20 operations each. Loop unrolled.
// Note(fbarchard): The following has lint warnings for multiple ; on
@@ -225,7 +230,7 @@
}
// Run your data through this.
-void SHA1Update(SHA1_CTX* context, const uint8* data, size_t input_len) {
+void SHA1Update(SHA1_CTX* context, const uint8_t* data, size_t input_len) {
size_t i = 0;
#ifdef VERBOSE
@@ -236,15 +241,15 @@
size_t index = (context->count[0] >> 3) & 63;
// Update number of bits.
- // TODO: Use uint64 instead of 2 uint32 for count.
+ // TODO: Use uint64_t instead of 2 uint32_t for count.
// count[0] has low 29 bits for byte count + 3 pad 0's making 32 bits for
// bit count.
- // Add bit count to low uint32
- context->count[0] += static_cast<uint32>(input_len << 3);
- if (context->count[0] < static_cast<uint32>(input_len << 3)) {
+ // Add bit count to low uint32_t
+ context->count[0] += static_cast<uint32_t>(input_len << 3);
+ if (context->count[0] < static_cast<uint32_t>(input_len << 3)) {
++context->count[1]; // if overlow (carry), add one to high word
}
- context->count[1] += static_cast<uint32>(input_len >> 29);
+ context->count[1] += static_cast<uint32_t>(input_len >> 29);
if ((index + input_len) > 63) {
i = 64 - index;
memcpy(&context->buffer[index], data, i);
@@ -262,21 +267,21 @@
}
// Add padding and return the message digest.
-void SHA1Final(SHA1_CTX* context, uint8 digest[SHA1_DIGEST_SIZE]) {
- uint8 finalcount[8];
+void SHA1Final(SHA1_CTX* context, uint8_t digest[SHA1_DIGEST_SIZE]) {
+ uint8_t finalcount[8];
for (int i = 0; i < 8; ++i) {
// Endian independent
- finalcount[i] = static_cast<uint8>(
- (context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8) ) & 255);
+ finalcount[i] = static_cast<uint8_t>(
+ (context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255);
}
- SHA1Update(context, reinterpret_cast<const uint8*>("\200"), 1);
+ SHA1Update(context, reinterpret_cast<const uint8_t*>("\200"), 1);
while ((context->count[0] & 504) != 448) {
- SHA1Update(context, reinterpret_cast<const uint8*>("\0"), 1);
+ SHA1Update(context, reinterpret_cast<const uint8_t*>("\0"), 1);
}
SHA1Update(context, finalcount, 8); // Should cause a SHA1Transform().
for (int i = 0; i < SHA1_DIGEST_SIZE; ++i) {
- digest[i] = static_cast<uint8>(
- (context->state[i >> 2] >> ((3 - (i & 3)) * 8) ) & 255);
+ digest[i] = static_cast<uint8_t>(
+ (context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
}
// Wipe variables.
diff --git a/webrtc/base/sha1.h b/webrtc/base/sha1.h
index 4862a00..aa5a6a5 100644
--- a/webrtc/base/sha1.h
+++ b/webrtc/base/sha1.h
@@ -5,27 +5,28 @@
*
*/
-// Ported to C++, Google style, under namespace rtc and uses basictypes.h
+// Ported to C++, Google style, under namespace rtc.
#ifndef WEBRTC_BASE_SHA1_H_
#define WEBRTC_BASE_SHA1_H_
-#include "webrtc/base/basictypes.h"
+#include <stdint.h>
+#include <stdlib.h>
namespace rtc {
struct SHA1_CTX {
- uint32 state[5];
- // TODO: Change bit count to uint64.
- uint32 count[2]; // Bit count of input.
- uint8 buffer[64];
+ uint32_t state[5];
+ // TODO: Change bit count to uint64_t.
+ uint32_t count[2]; // Bit count of input.
+ uint8_t buffer[64];
};
#define SHA1_DIGEST_SIZE 20
void SHA1Init(SHA1_CTX* context);
-void SHA1Update(SHA1_CTX* context, const uint8* data, size_t len);
-void SHA1Final(SHA1_CTX* context, uint8 digest[SHA1_DIGEST_SIZE]);
+void SHA1Update(SHA1_CTX* context, const uint8_t* data, size_t len);
+void SHA1Final(SHA1_CTX* context, uint8_t digest[SHA1_DIGEST_SIZE]);
#endif // WEBRTC_BASE_SHA1_H_
diff --git a/webrtc/base/sha1digest.cc b/webrtc/base/sha1digest.cc
index 5ba0c54..c090a06 100644
--- a/webrtc/base/sha1digest.cc
+++ b/webrtc/base/sha1digest.cc
@@ -17,14 +17,14 @@
}
void Sha1Digest::Update(const void* buf, size_t len) {
- SHA1Update(&ctx_, static_cast<const uint8*>(buf), len);
+ SHA1Update(&ctx_, static_cast<const uint8_t*>(buf), len);
}
size_t Sha1Digest::Finish(void* buf, size_t len) {
if (len < kSize) {
return 0;
}
- SHA1Final(&ctx_, static_cast<uint8*>(buf));
+ SHA1Final(&ctx_, static_cast<uint8_t*>(buf));
SHA1Init(&ctx_); // Reset for next use.
return kSize;
}
diff --git a/webrtc/base/sharedexclusivelock_unittest.cc b/webrtc/base/sharedexclusivelock_unittest.cc
index c124db5..2857e00 100644
--- a/webrtc/base/sharedexclusivelock_unittest.cc
+++ b/webrtc/base/sharedexclusivelock_unittest.cc
@@ -20,8 +20,8 @@
namespace rtc {
-static const uint32 kMsgRead = 0;
-static const uint32 kMsgWrite = 0;
+static const uint32_t kMsgRead = 0;
+static const uint32_t kMsgWrite = 0;
static const int kNoWaitThresholdInMs = 10;
static const int kWaitThresholdInMs = 80;
static const int kProcessTimeInMs = 100;
@@ -69,7 +69,7 @@
TypedMessageData<int*>* message_data =
static_cast<TypedMessageData<int*>*>(message->pdata);
- uint32 start_time = Time();
+ uint32_t start_time = Time();
{
SharedScope ss(shared_exclusive_lock_);
waiting_time_in_ms_ = TimeDiff(Time(), start_time);
@@ -102,7 +102,7 @@
TypedMessageData<int>* message_data =
static_cast<TypedMessageData<int>*>(message->pdata);
- uint32 start_time = Time();
+ uint32_t start_time = Time();
{
ExclusiveScope es(shared_exclusive_lock_);
waiting_time_in_ms_ = TimeDiff(Time(), start_time);
diff --git a/webrtc/base/socket.h b/webrtc/base/socket.h
index 5512c5d..8d98d27 100644
--- a/webrtc/base/socket.h
+++ b/webrtc/base/socket.h
@@ -158,10 +158,10 @@
};
virtual ConnState GetState() const = 0;
- // Fills in the given uint16 with the current estimate of the MTU along the
+ // Fills in the given uint16_t with the current estimate of the MTU along the
// path to the address to which this socket is connected. NOTE: This method
// can block for up to 10 seconds on Windows.
- virtual int EstimateMTU(uint16* mtu) = 0;
+ virtual int EstimateMTU(uint16_t* mtu) = 0;
enum Option {
OPT_DONTFRAGMENT,
diff --git a/webrtc/base/socket_unittest.cc b/webrtc/base/socket_unittest.cc
index 6104eda..d078d7c 100644
--- a/webrtc/base/socket_unittest.cc
+++ b/webrtc/base/socket_unittest.cc
@@ -929,7 +929,7 @@
client->SetOption(rtc::Socket::OPT_SNDBUF, send_buffer_size);
int error = 0;
- uint32 start_ms = Time();
+ uint32_t start_ms = Time();
int sent_packet_num = 0;
int expected_error = EWOULDBLOCK;
while (start_ms + kTimeout > Time()) {
@@ -990,7 +990,7 @@
mtu_socket(
ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM));
mtu_socket->Bind(SocketAddress(loopback, 0));
- uint16 mtu;
+ uint16_t mtu;
// should fail until we connect
ASSERT_EQ(-1, mtu_socket->EstimateMTU(&mtu));
mtu_socket->Connect(SocketAddress(loopback, 0));
diff --git a/webrtc/base/socketadapters.cc b/webrtc/base/socketadapters.cc
index b1c2a87..af2efb8 100644
--- a/webrtc/base/socketadapters.cc
+++ b/webrtc/base/socketadapters.cc
@@ -137,41 +137,41 @@
// This is a SSL v2 CLIENT_HELLO message.
// TODO: Should this have a session id? The response doesn't have a
// certificate, so the hello should have a session id.
-static const uint8 kSslClientHello[] = {
- 0x80, 0x46, // msg len
- 0x01, // CLIENT_HELLO
- 0x03, 0x01, // SSL 3.1
- 0x00, 0x2d, // ciphersuite len
- 0x00, 0x00, // session id len
- 0x00, 0x10, // challenge len
- 0x01, 0x00, 0x80, 0x03, 0x00, 0x80, 0x07, 0x00, 0xc0, // ciphersuites
- 0x06, 0x00, 0x40, 0x02, 0x00, 0x80, 0x04, 0x00, 0x80, //
- 0x00, 0x00, 0x04, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x0a, //
- 0x00, 0xfe, 0xfe, 0x00, 0x00, 0x09, 0x00, 0x00, 0x64, //
- 0x00, 0x00, 0x62, 0x00, 0x00, 0x03, 0x00, 0x00, 0x06, //
- 0x1f, 0x17, 0x0c, 0xa6, 0x2f, 0x00, 0x78, 0xfc, // challenge
- 0x46, 0x55, 0x2e, 0xb1, 0x83, 0x39, 0xf1, 0xea //
+static const uint8_t kSslClientHello[] = {
+ 0x80, 0x46, // msg len
+ 0x01, // CLIENT_HELLO
+ 0x03, 0x01, // SSL 3.1
+ 0x00, 0x2d, // ciphersuite len
+ 0x00, 0x00, // session id len
+ 0x00, 0x10, // challenge len
+ 0x01, 0x00, 0x80, 0x03, 0x00, 0x80, 0x07, 0x00, 0xc0, // ciphersuites
+ 0x06, 0x00, 0x40, 0x02, 0x00, 0x80, 0x04, 0x00, 0x80, //
+ 0x00, 0x00, 0x04, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x0a, //
+ 0x00, 0xfe, 0xfe, 0x00, 0x00, 0x09, 0x00, 0x00, 0x64, //
+ 0x00, 0x00, 0x62, 0x00, 0x00, 0x03, 0x00, 0x00, 0x06, //
+ 0x1f, 0x17, 0x0c, 0xa6, 0x2f, 0x00, 0x78, 0xfc, // challenge
+ 0x46, 0x55, 0x2e, 0xb1, 0x83, 0x39, 0xf1, 0xea //
};
// This is a TLSv1 SERVER_HELLO message.
-static const uint8 kSslServerHello[] = {
- 0x16, // handshake message
- 0x03, 0x01, // SSL 3.1
- 0x00, 0x4a, // message len
- 0x02, // SERVER_HELLO
- 0x00, 0x00, 0x46, // handshake len
- 0x03, 0x01, // SSL 3.1
- 0x42, 0x85, 0x45, 0xa7, 0x27, 0xa9, 0x5d, 0xa0, // server random
- 0xb3, 0xc5, 0xe7, 0x53, 0xda, 0x48, 0x2b, 0x3f, //
- 0xc6, 0x5a, 0xca, 0x89, 0xc1, 0x58, 0x52, 0xa1, //
- 0x78, 0x3c, 0x5b, 0x17, 0x46, 0x00, 0x85, 0x3f, //
- 0x20, // session id len
- 0x0e, 0xd3, 0x06, 0x72, 0x5b, 0x5b, 0x1b, 0x5f, // session id
- 0x15, 0xac, 0x13, 0xf9, 0x88, 0x53, 0x9d, 0x9b, //
- 0xe8, 0x3d, 0x7b, 0x0c, 0x30, 0x32, 0x6e, 0x38, //
- 0x4d, 0xa2, 0x75, 0x57, 0x41, 0x6c, 0x34, 0x5c, //
- 0x00, 0x04, // RSA/RC4-128/MD5
- 0x00 // null compression
+static const uint8_t kSslServerHello[] = {
+ 0x16, // handshake message
+ 0x03, 0x01, // SSL 3.1
+ 0x00, 0x4a, // message len
+ 0x02, // SERVER_HELLO
+ 0x00, 0x00, 0x46, // handshake len
+ 0x03, 0x01, // SSL 3.1
+ 0x42, 0x85, 0x45, 0xa7, 0x27, 0xa9, 0x5d, 0xa0, // server random
+ 0xb3, 0xc5, 0xe7, 0x53, 0xda, 0x48, 0x2b, 0x3f, //
+ 0xc6, 0x5a, 0xca, 0x89, 0xc1, 0x58, 0x52, 0xa1, //
+ 0x78, 0x3c, 0x5b, 0x17, 0x46, 0x00, 0x85, 0x3f, //
+ 0x20, // session id len
+ 0x0e, 0xd3, 0x06, 0x72, 0x5b, 0x5b, 0x1b, 0x5f, // session id
+ 0x15, 0xac, 0x13, 0xf9, 0x88, 0x53, 0x9d, 0x9b, //
+ 0xe8, 0x3d, 0x7b, 0x0c, 0x30, 0x32, 0x6e, 0x38, //
+ 0x4d, 0xa2, 0x75, 0x57, 0x41, 0x6c, 0x34, 0x5c, //
+ 0x00, 0x04, // RSA/RC4-128/MD5
+ 0x00 // null compression
};
AsyncSSLSocket::AsyncSSLSocket(AsyncSocket* socket)
@@ -564,7 +564,7 @@
ByteBuffer response(data, *len);
if (state_ == SS_HELLO) {
- uint8 ver, method;
+ uint8_t ver, method;
if (!response.ReadUInt8(&ver) ||
!response.ReadUInt8(&method))
return;
@@ -583,7 +583,7 @@
return;
}
} else if (state_ == SS_AUTH) {
- uint8 ver, status;
+ uint8_t ver, status;
if (!response.ReadUInt8(&ver) ||
!response.ReadUInt8(&status))
return;
@@ -595,7 +595,7 @@
SendConnect();
} else if (state_ == SS_CONNECT) {
- uint8 ver, rep, rsv, atyp;
+ uint8_t ver, rep, rsv, atyp;
if (!response.ReadUInt8(&ver) ||
!response.ReadUInt8(&rep) ||
!response.ReadUInt8(&rsv) ||
@@ -607,15 +607,15 @@
return;
}
- uint16 port;
+ uint16_t port;
if (atyp == 1) {
- uint32 addr;
+ uint32_t addr;
if (!response.ReadUInt32(&addr) ||
!response.ReadUInt16(&port))
return;
LOG(LS_VERBOSE) << "Bound on " << addr << ":" << port;
} else if (atyp == 3) {
- uint8 len;
+ uint8_t len;
std::string addr;
if (!response.ReadUInt8(&len) ||
!response.ReadString(&addr, len) ||
@@ -670,9 +670,9 @@
void AsyncSocksProxySocket::SendAuth() {
ByteBuffer request;
request.WriteUInt8(1); // Negotiation Version
- request.WriteUInt8(static_cast<uint8>(user_.size()));
+ request.WriteUInt8(static_cast<uint8_t>(user_.size()));
request.WriteString(user_); // Username
- request.WriteUInt8(static_cast<uint8>(pass_.GetLength()));
+ request.WriteUInt8(static_cast<uint8_t>(pass_.GetLength()));
size_t len = pass_.GetLength() + 1;
char * sensitive = new char[len];
pass_.CopyTo(sensitive, true);
@@ -691,7 +691,7 @@
if (dest_.IsUnresolved()) {
std::string hostname = dest_.hostname();
request.WriteUInt8(3); // DOMAINNAME
- request.WriteUInt8(static_cast<uint8>(hostname.size()));
+ request.WriteUInt8(static_cast<uint8_t>(hostname.size()));
request.WriteString(hostname); // Destination Hostname
} else {
request.WriteUInt8(1); // IPV4
@@ -738,7 +738,7 @@
}
void AsyncSocksProxyServerSocket::HandleHello(ByteBuffer* request) {
- uint8 ver, num_methods;
+ uint8_t ver, num_methods;
if (!request->ReadUInt8(&ver) ||
!request->ReadUInt8(&num_methods)) {
Error(0);
@@ -751,7 +751,7 @@
}
// Handle either no-auth (0) or user/pass auth (2)
- uint8 method = 0xFF;
+ uint8_t method = 0xFF;
if (num_methods > 0 && !request->ReadUInt8(&method)) {
Error(0);
return;
@@ -768,7 +768,7 @@
}
}
-void AsyncSocksProxyServerSocket::SendHelloReply(uint8 method) {
+void AsyncSocksProxyServerSocket::SendHelloReply(uint8_t method) {
ByteBuffer response;
response.WriteUInt8(5); // Socks Version
response.WriteUInt8(method); // Auth method
@@ -776,7 +776,7 @@
}
void AsyncSocksProxyServerSocket::HandleAuth(ByteBuffer* request) {
- uint8 ver, user_len, pass_len;
+ uint8_t ver, user_len, pass_len;
std::string user, pass;
if (!request->ReadUInt8(&ver) ||
!request->ReadUInt8(&user_len) ||
@@ -792,7 +792,7 @@
state_ = SS_CONNECT;
}
-void AsyncSocksProxyServerSocket::SendAuthReply(uint8 result) {
+void AsyncSocksProxyServerSocket::SendAuthReply(uint8_t result) {
ByteBuffer response;
response.WriteUInt8(1); // Negotiation Version
response.WriteUInt8(result);
@@ -800,9 +800,9 @@
}
void AsyncSocksProxyServerSocket::HandleConnect(ByteBuffer* request) {
- uint8 ver, command, reserved, addr_type;
- uint32 ip;
- uint16 port;
+ uint8_t ver, command, reserved, addr_type;
+ uint32_t ip;
+ uint16_t port;
if (!request->ReadUInt8(&ver) ||
!request->ReadUInt8(&command) ||
!request->ReadUInt8(&reserved) ||
diff --git a/webrtc/base/socketadapters.h b/webrtc/base/socketadapters.h
index b7d3d4b4..ece591d 100644
--- a/webrtc/base/socketadapters.h
+++ b/webrtc/base/socketadapters.h
@@ -196,9 +196,9 @@
void DirectSend(const ByteBuffer& buf);
void HandleHello(ByteBuffer* request);
- void SendHelloReply(uint8 method);
+ void SendHelloReply(uint8_t method);
void HandleAuth(ByteBuffer* request);
- void SendAuthReply(uint8 result);
+ void SendAuthReply(uint8_t result);
void HandleConnect(ByteBuffer* request);
void SendConnectResult(int result, const SocketAddress& addr) override;
diff --git a/webrtc/base/socketaddress.cc b/webrtc/base/socketaddress.cc
index b15c0c4..3f13c38 100644
--- a/webrtc/base/socketaddress.cc
+++ b/webrtc/base/socketaddress.cc
@@ -47,7 +47,7 @@
SetPort(port);
}
-SocketAddress::SocketAddress(uint32 ip_as_host_order_integer, int port) {
+SocketAddress::SocketAddress(uint32_t ip_as_host_order_integer, int port) {
SetIP(IPAddress(ip_as_host_order_integer));
SetPort(port);
}
@@ -86,7 +86,7 @@
return *this;
}
-void SocketAddress::SetIP(uint32 ip_as_host_order_integer) {
+void SocketAddress::SetIP(uint32_t ip_as_host_order_integer) {
hostname_.clear();
literal_ = false;
ip_ = IPAddress(ip_as_host_order_integer);
@@ -109,7 +109,7 @@
scope_id_ = 0;
}
-void SocketAddress::SetResolvedIP(uint32 ip_as_host_order_integer) {
+void SocketAddress::SetResolvedIP(uint32_t ip_as_host_order_integer) {
ip_ = IPAddress(ip_as_host_order_integer);
scope_id_ = 0;
}
@@ -121,10 +121,10 @@
void SocketAddress::SetPort(int port) {
ASSERT((0 <= port) && (port < 65536));
- port_ = static_cast<uint16>(port);
+ port_ = static_cast<uint16_t>(port);
}
-uint32 SocketAddress::ip() const {
+uint32_t SocketAddress::ip() const {
return ip_.v4AddressAsHostOrderInteger();
}
@@ -132,7 +132,7 @@
return ip_;
}
-uint16 SocketAddress::port() const {
+uint16_t SocketAddress::port() const {
return port_;
}
@@ -279,7 +279,9 @@
}
static size_t ToSockAddrStorageHelper(sockaddr_storage* addr,
- IPAddress ip, uint16 port, int scope_id) {
+ IPAddress ip,
+ uint16_t port,
+ int scope_id) {
memset(addr, 0, sizeof(sockaddr_storage));
addr->ss_family = static_cast<unsigned short>(ip.family());
if (addr->ss_family == AF_INET6) {
@@ -305,15 +307,15 @@
return ToSockAddrStorageHelper(addr, ip_, port_, scope_id_);
}
-std::string SocketAddress::IPToString(uint32 ip_as_host_order_integer) {
+std::string SocketAddress::IPToString(uint32_t ip_as_host_order_integer) {
return IPAddress(ip_as_host_order_integer).ToString();
}
-std::string IPToSensitiveString(uint32 ip_as_host_order_integer) {
+std::string IPToSensitiveString(uint32_t ip_as_host_order_integer) {
return IPAddress(ip_as_host_order_integer).ToSensitiveString();
}
-bool SocketAddress::StringToIP(const std::string& hostname, uint32* ip) {
+bool SocketAddress::StringToIP(const std::string& hostname, uint32_t* ip) {
in_addr addr;
if (rtc::inet_pton(AF_INET, hostname.c_str(), &addr) == 0)
return false;
@@ -340,8 +342,8 @@
return false;
}
-uint32 SocketAddress::StringToIP(const std::string& hostname) {
- uint32 ip = 0;
+uint32_t SocketAddress::StringToIP(const std::string& hostname) {
+ uint32_t ip = 0;
StringToIP(hostname, &ip);
return ip;
}
diff --git a/webrtc/base/socketaddress.h b/webrtc/base/socketaddress.h
index f8256fc..44183f3 100644
--- a/webrtc/base/socketaddress.h
+++ b/webrtc/base/socketaddress.h
@@ -36,7 +36,7 @@
// Creates the address with the given IP and port.
// IP is given as an integer in host byte order. V4 only, to be deprecated.
- SocketAddress(uint32 ip_as_host_order_integer, int port);
+ SocketAddress(uint32_t ip_as_host_order_integer, int port);
// Creates the address with the given IP and port.
SocketAddress(const IPAddress& ip, int port);
@@ -58,7 +58,7 @@
// Changes the IP of this address to the given one, and clears the hostname
// IP is given as an integer in host byte order. V4 only, to be deprecated..
- void SetIP(uint32 ip_as_host_order_integer);
+ void SetIP(uint32_t ip_as_host_order_integer);
// Changes the IP of this address to the given one, and clears the hostname.
void SetIP(const IPAddress& ip);
@@ -70,7 +70,7 @@
// Sets the IP address while retaining the hostname. Useful for bypassing
// DNS for a pre-resolved IP.
// IP is given as an integer in host byte order. V4 only, to be deprecated.
- void SetResolvedIP(uint32 ip_as_host_order_integer);
+ void SetResolvedIP(uint32_t ip_as_host_order_integer);
// Sets the IP address while retaining the hostname. Useful for bypassing
// DNS for a pre-resolved IP.
@@ -84,14 +84,14 @@
// Returns the IP address as a host byte order integer.
// Returns 0 for non-v4 addresses.
- uint32 ip() const;
+ uint32_t ip() const;
const IPAddress& ipaddr() const;
int family() const {return ip_.family(); }
// Returns the port part of this address.
- uint16 port() const;
+ uint16_t port() const;
// Returns the scope ID associated with this address. Scope IDs are a
// necessary addition to IPv6 link-local addresses, with different network
@@ -181,18 +181,18 @@
// Converts the IP address given in 'compact form' into dotted form.
// IP is given as an integer in host byte order. V4 only, to be deprecated.
// TODO: Deprecate this.
- static std::string IPToString(uint32 ip_as_host_order_integer);
+ static std::string IPToString(uint32_t ip_as_host_order_integer);
// Same as IPToString but anonymizes it by hiding the last part.
// TODO: Deprecate this.
- static std::string IPToSensitiveString(uint32 ip_as_host_order_integer);
+ static std::string IPToSensitiveString(uint32_t ip_as_host_order_integer);
// Converts the IP address given in dotted form into compact form.
// Only dotted names (A.B.C.D) are converted.
// Output integer is returned in host byte order.
// TODO: Deprecate, replace wth agnostic versions.
- static bool StringToIP(const std::string& str, uint32* ip);
- static uint32 StringToIP(const std::string& str);
+ static bool StringToIP(const std::string& str, uint32_t* ip);
+ static uint32_t StringToIP(const std::string& str);
// Converts the IP address given in printable form into an IPAddress.
static bool StringToIP(const std::string& str, IPAddress* ip);
@@ -200,7 +200,7 @@
private:
std::string hostname_;
IPAddress ip_;
- uint16 port_;
+ uint16_t port_;
int scope_id_;
bool literal_; // Indicates that 'hostname_' contains a literal IP string.
};
diff --git a/webrtc/base/sslfingerprint.cc b/webrtc/base/sslfingerprint.cc
index a610181..1939b4f 100644
--- a/webrtc/base/sslfingerprint.cc
+++ b/webrtc/base/sslfingerprint.cc
@@ -30,7 +30,7 @@
SSLFingerprint* SSLFingerprint::Create(
const std::string& algorithm, const rtc::SSLCertificate* cert) {
- uint8 digest_val[64];
+ uint8_t digest_val[64];
size_t digest_len;
bool ret = cert->ComputeDigest(
algorithm, digest_val, sizeof(digest_val), &digest_len);
@@ -58,13 +58,13 @@
if (!value_len)
return NULL;
- return new SSLFingerprint(algorithm,
- reinterpret_cast<uint8*>(value),
+ return new SSLFingerprint(algorithm, reinterpret_cast<uint8_t*>(value),
value_len);
}
-SSLFingerprint::SSLFingerprint(
- const std::string& algorithm, const uint8* digest_in, size_t digest_len)
+SSLFingerprint::SSLFingerprint(const std::string& algorithm,
+ const uint8_t* digest_in,
+ size_t digest_len)
: algorithm(algorithm) {
digest.SetData(digest_in, digest_len);
}
diff --git a/webrtc/base/sslfingerprint.h b/webrtc/base/sslfingerprint.h
index 355c6ba..735238d 100644
--- a/webrtc/base/sslfingerprint.h
+++ b/webrtc/base/sslfingerprint.h
@@ -31,7 +31,8 @@
static SSLFingerprint* CreateFromRfc4572(const std::string& algorithm,
const std::string& fingerprint);
- SSLFingerprint(const std::string& algorithm, const uint8* digest_in,
+ SSLFingerprint(const std::string& algorithm,
+ const uint8_t* digest_in,
size_t digest_len);
SSLFingerprint(const SSLFingerprint& from);
diff --git a/webrtc/base/sslstreamadapter.cc b/webrtc/base/sslstreamadapter.cc
index 0ce49d1..9d52975 100644
--- a/webrtc/base/sslstreamadapter.cc
+++ b/webrtc/base/sslstreamadapter.cc
@@ -57,10 +57,10 @@
}
bool SSLStreamAdapter::ExportKeyingMaterial(const std::string& label,
- const uint8* context,
+ const uint8_t* context,
size_t context_len,
bool use_context,
- uint8* result,
+ uint8_t* result,
size_t result_len) {
return false; // Default is unsupported
}
diff --git a/webrtc/base/sslstreamadapter.h b/webrtc/base/sslstreamadapter.h
index fa49651..65a7729 100644
--- a/webrtc/base/sslstreamadapter.h
+++ b/webrtc/base/sslstreamadapter.h
@@ -167,10 +167,10 @@
// result -- where to put the computed value
// result_len -- the length of the computed value
virtual bool ExportKeyingMaterial(const std::string& label,
- const uint8* context,
+ const uint8_t* context,
size_t context_len,
bool use_context,
- uint8* result,
+ uint8_t* result,
size_t result_len);
// DTLS-SRTP interface
diff --git a/webrtc/base/sslstreamadapter_unittest.cc b/webrtc/base/sslstreamadapter_unittest.cc
index 386fe4f..c65bb63 100644
--- a/webrtc/base/sslstreamadapter_unittest.cc
+++ b/webrtc/base/sslstreamadapter_unittest.cc
@@ -334,7 +334,7 @@
size_t data_len, size_t *written,
int *error) {
// Randomly drop loss_ percent of packets
- if (rtc::CreateRandomId() % 100 < static_cast<uint32>(loss_)) {
+ if (rtc::CreateRandomId() % 100 < static_cast<uint32_t>(loss_)) {
LOG(LS_INFO) << "Randomly dropping packet, size=" << data_len;
*written = data_len;
return rtc::SR_SUCCESS;
diff --git a/webrtc/base/systeminfo.cc b/webrtc/base/systeminfo.cc
index 540de82..bfc96b3 100644
--- a/webrtc/base/systeminfo.cc
+++ b/webrtc/base/systeminfo.cc
@@ -161,8 +161,8 @@
// Returns the amount of installed physical memory in Bytes. Cacheable.
// Returns -1 on error.
-int64 SystemInfo::GetMemorySize() {
- int64 memory = -1;
+int64_t SystemInfo::GetMemorySize() {
+ int64_t memory = -1;
#if defined(WEBRTC_WIN)
MEMORYSTATUSEX status = {0};
@@ -180,8 +180,8 @@
if (error || memory == 0)
memory = -1;
#elif defined(WEBRTC_LINUX)
- memory = static_cast<int64>(sysconf(_SC_PHYS_PAGES)) *
- static_cast<int64>(sysconf(_SC_PAGESIZE));
+ memory = static_cast<int64_t>(sysconf(_SC_PHYS_PAGES)) *
+ static_cast<int64_t>(sysconf(_SC_PAGESIZE));
if (memory < 0) {
LOG(LS_WARNING) << "sysconf(_SC_PHYS_PAGES) failed."
<< "sysconf(_SC_PHYS_PAGES) " << sysconf(_SC_PHYS_PAGES)
diff --git a/webrtc/base/systeminfo.h b/webrtc/base/systeminfo.h
index e223702..99d18b2 100644
--- a/webrtc/base/systeminfo.h
+++ b/webrtc/base/systeminfo.h
@@ -36,7 +36,7 @@
Architecture GetCpuArchitecture();
std::string GetCpuVendor();
// Total amount of physical memory, in bytes.
- int64 GetMemorySize();
+ int64_t GetMemorySize();
// The model name of the machine, e.g. "MacBookAir1,1"
std::string GetMachineModel();
diff --git a/webrtc/base/task.cc b/webrtc/base/task.cc
index d81a6d2..bdf8f1d 100644
--- a/webrtc/base/task.cc
+++ b/webrtc/base/task.cc
@@ -14,7 +14,7 @@
namespace rtc {
-int32 Task::unique_id_seed_ = 0;
+int32_t Task::unique_id_seed_ = 0;
Task::Task(TaskParent *parent)
: TaskParent(this, parent),
@@ -48,11 +48,11 @@
}
}
-int64 Task::CurrentTime() {
+int64_t Task::CurrentTime() {
return GetRunner()->CurrentTime();
}
-int64 Task::ElapsedTime() {
+int64_t Task::ElapsedTime() {
return CurrentTime() - start_time_;
}
@@ -240,7 +240,7 @@
}
void Task::ResetTimeout() {
- int64 previous_timeout_time = timeout_time_;
+ int64_t previous_timeout_time = timeout_time_;
bool timeout_allowed = (state_ != STATE_INIT)
&& (state_ != STATE_DONE)
&& (state_ != STATE_ERROR);
@@ -254,7 +254,7 @@
}
void Task::ClearTimeout() {
- int64 previous_timeout_time = timeout_time_;
+ int64_t previous_timeout_time = timeout_time_;
timeout_time_ = 0;
GetRunner()->UpdateTaskTimeout(this, previous_timeout_time);
}
diff --git a/webrtc/base/task.h b/webrtc/base/task.h
index 3e43e11..28702e4 100644
--- a/webrtc/base/task.h
+++ b/webrtc/base/task.h
@@ -95,7 +95,7 @@
Task(TaskParent *parent);
~Task() override;
- int32 unique_id() { return unique_id_; }
+ int32_t unique_id() { return unique_id_; }
void Start();
void Step();
@@ -103,14 +103,14 @@
bool HasError() const { return (GetState() == STATE_ERROR); }
bool Blocked() const { return blocked_; }
bool IsDone() const { return done_; }
- int64 ElapsedTime();
+ int64_t ElapsedTime();
// Called from outside to stop task without any more callbacks
void Abort(bool nowake = false);
bool TimedOut();
- int64 timeout_time() const { return timeout_time_; }
+ int64_t timeout_time() const { return timeout_time_; }
int timeout_seconds() const { return timeout_seconds_; }
void set_timeout_seconds(int timeout_seconds);
@@ -134,7 +134,7 @@
// Called inside to advise that the task should wake and signal an error
void Error();
- int64 CurrentTime();
+ int64_t CurrentTime();
virtual std::string GetStateName(int state) const;
virtual int Process(int state);
@@ -160,13 +160,13 @@
bool aborted_;
bool busy_;
bool error_;
- int64 start_time_;
- int64 timeout_time_;
+ int64_t start_time_;
+ int64_t timeout_time_;
int timeout_seconds_;
bool timeout_suspended_;
- int32 unique_id_;
-
- static int32 unique_id_seed_;
+ int32_t unique_id_;
+
+ static int32_t unique_id_seed_;
};
} // namespace rtc
diff --git a/webrtc/base/task_unittest.cc b/webrtc/base/task_unittest.cc
index 1135a73..7f67841 100644
--- a/webrtc/base/task_unittest.cc
+++ b/webrtc/base/task_unittest.cc
@@ -31,8 +31,8 @@
namespace rtc {
-static int64 GetCurrentTime() {
- return static_cast<int64>(Time()) * 10000;
+static int64_t GetCurrentTime() {
+ return static_cast<int64_t>(Time()) * 10000;
}
// feel free to change these numbers. Note that '0' won't work, though
@@ -98,9 +98,7 @@
class MyTaskRunner : public TaskRunner {
public:
virtual void WakeTasks() { RunTasks(); }
- virtual int64 CurrentTime() {
- return GetCurrentTime();
- }
+ virtual int64_t CurrentTime() { return GetCurrentTime(); }
bool timeout_change() const {
return timeout_change_;
@@ -490,9 +488,7 @@
DeleteTestTaskRunner() {
}
virtual void WakeTasks() { }
- virtual int64 CurrentTime() {
- return GetCurrentTime();
- }
+ virtual int64_t CurrentTime() { return GetCurrentTime(); }
private:
RTC_DISALLOW_COPY_AND_ASSIGN(DeleteTestTaskRunner);
};
diff --git a/webrtc/base/taskrunner.cc b/webrtc/base/taskrunner.cc
index bc4ab5e..e7278f1 100644
--- a/webrtc/base/taskrunner.cc
+++ b/webrtc/base/taskrunner.cc
@@ -64,7 +64,7 @@
tasks_running_ = true;
- int64 previous_timeout_time = next_task_timeout();
+ int64_t previous_timeout_time = next_task_timeout();
int did_run = true;
while (did_run) {
@@ -135,7 +135,7 @@
}
}
-int64 TaskRunner::next_task_timeout() const {
+int64_t TaskRunner::next_task_timeout() const {
if (next_timeout_task_) {
return next_timeout_task_->timeout_time();
}
@@ -150,9 +150,9 @@
// effectively making the task scheduler O-1 instead of O-N
void TaskRunner::UpdateTaskTimeout(Task* task,
- int64 previous_task_timeout_time) {
+ int64_t previous_task_timeout_time) {
ASSERT(task != NULL);
- int64 previous_timeout_time = next_task_timeout();
+ int64_t previous_timeout_time = next_task_timeout();
bool task_is_timeout_task = next_timeout_task_ != NULL &&
task->unique_id() == next_timeout_task_->unique_id();
if (task_is_timeout_task) {
@@ -190,7 +190,7 @@
// we're not excluding it
// it has the closest timeout time
- int64 next_timeout_time = 0;
+ int64_t next_timeout_time = 0;
next_timeout_task_ = NULL;
for (size_t i = 0; i < tasks_.size(); ++i) {
@@ -210,8 +210,8 @@
}
}
-void TaskRunner::CheckForTimeoutChange(int64 previous_timeout_time) {
- int64 next_timeout = next_task_timeout();
+void TaskRunner::CheckForTimeoutChange(int64_t previous_timeout_time) {
+ int64_t next_timeout = next_task_timeout();
bool timeout_change = (previous_timeout_time == 0 && next_timeout != 0) ||
next_timeout < previous_timeout_time ||
(previous_timeout_time <= CurrentTime() &&
diff --git a/webrtc/base/taskrunner.h b/webrtc/base/taskrunner.h
index bdcebc4..9a43aac0 100644
--- a/webrtc/base/taskrunner.h
+++ b/webrtc/base/taskrunner.h
@@ -20,9 +20,9 @@
namespace rtc {
class Task;
-const int64 kSecToMsec = 1000;
-const int64 kMsecTo100ns = 10000;
-const int64 kSecTo100ns = kSecToMsec * kMsecTo100ns;
+const int64_t kSecToMsec = 1000;
+const int64_t kMsecTo100ns = 10000;
+const int64_t kSecTo100ns = kSecToMsec * kMsecTo100ns;
class TaskRunner : public TaskParent, public sigslot::has_slots<> {
public:
@@ -36,13 +36,13 @@
// the units and that rollover while the computer is running.
//
// On Windows, GetSystemTimeAsFileTime is the typical implementation.
- virtual int64 CurrentTime() = 0 ;
+ virtual int64_t CurrentTime() = 0;
void StartTask(Task *task);
void RunTasks();
void PollTasks();
- void UpdateTaskTimeout(Task *task, int64 previous_task_timeout_time);
+ void UpdateTaskTimeout(Task* task, int64_t previous_task_timeout_time);
#ifdef _DEBUG
bool is_ok_to_delete(Task* task) {
@@ -60,7 +60,7 @@
// Returns the next absolute time when a task times out
// OR "0" if there is no next timeout.
- int64 next_task_timeout() const;
+ int64_t next_task_timeout() const;
protected:
// The primary usage of this method is to know if
@@ -82,7 +82,7 @@
private:
void InternalRunTasks(bool in_destructor);
- void CheckForTimeoutChange(int64 previous_timeout_time);
+ void CheckForTimeoutChange(int64_t previous_timeout_time);
std::vector<Task *> tasks_;
Task *next_timeout_task_;
diff --git a/webrtc/base/testclient.cc b/webrtc/base/testclient.cc
index 8483c4e..c7484fa 100644
--- a/webrtc/base/testclient.cc
+++ b/webrtc/base/testclient.cc
@@ -34,7 +34,7 @@
bool TestClient::CheckConnState(AsyncPacketSocket::State state) {
// Wait for our timeout value until the socket reaches the desired state.
- uint32 end = TimeAfter(kTimeoutMs);
+ uint32_t end = TimeAfter(kTimeoutMs);
while (socket_->GetState() != state && TimeUntil(end) > 0)
Thread::Current()->ProcessMessages(1);
return (socket_->GetState() == state);
@@ -63,7 +63,7 @@
// Pumping another thread's queue could lead to messages being dispatched from
// the wrong thread to non-thread-safe objects.
- uint32 end = TimeAfter(timeout_ms);
+ uint32_t end = TimeAfter(timeout_ms);
while (TimeUntil(end) > 0) {
{
CritScope cs(&crit_);
diff --git a/webrtc/base/testutils.h b/webrtc/base/testutils.h
index 4c978e7..e56895d 100644
--- a/webrtc/base/testutils.h
+++ b/webrtc/base/testutils.h
@@ -542,29 +542,33 @@
// order
///////////////////////////////////////////////////////////////////////////////
-#define BYTE_CAST(x) static_cast<uint8>((x) & 0xFF)
+#define BYTE_CAST(x) static_cast<uint8_t>((x)&0xFF)
// Declare a N-bit integer as a little-endian sequence of bytes
-#define LE16(x) BYTE_CAST(((uint16)x) >> 0), BYTE_CAST(((uint16)x) >> 8)
+#define LE16(x) BYTE_CAST(((uint16_t)x) >> 0), BYTE_CAST(((uint16_t)x) >> 8)
-#define LE32(x) BYTE_CAST(((uint32)x) >> 0), BYTE_CAST(((uint32)x) >> 8), \
- BYTE_CAST(((uint32)x) >> 16), BYTE_CAST(((uint32)x) >> 24)
+#define LE32(x) \
+ BYTE_CAST(((uint32_t)x) >> 0), BYTE_CAST(((uint32_t)x) >> 8), \
+ BYTE_CAST(((uint32_t)x) >> 16), BYTE_CAST(((uint32_t)x) >> 24)
-#define LE64(x) BYTE_CAST(((uint64)x) >> 0), BYTE_CAST(((uint64)x) >> 8), \
- BYTE_CAST(((uint64)x) >> 16), BYTE_CAST(((uint64)x) >> 24), \
- BYTE_CAST(((uint64)x) >> 32), BYTE_CAST(((uint64)x) >> 40), \
- BYTE_CAST(((uint64)x) >> 48), BYTE_CAST(((uint64)x) >> 56)
+#define LE64(x) \
+ BYTE_CAST(((uint64_t)x) >> 0), BYTE_CAST(((uint64_t)x) >> 8), \
+ BYTE_CAST(((uint64_t)x) >> 16), BYTE_CAST(((uint64_t)x) >> 24), \
+ BYTE_CAST(((uint64_t)x) >> 32), BYTE_CAST(((uint64_t)x) >> 40), \
+ BYTE_CAST(((uint64_t)x) >> 48), BYTE_CAST(((uint64_t)x) >> 56)
// Declare a N-bit integer as a big-endian (Internet) sequence of bytes
-#define BE16(x) BYTE_CAST(((uint16)x) >> 8), BYTE_CAST(((uint16)x) >> 0)
+#define BE16(x) BYTE_CAST(((uint16_t)x) >> 8), BYTE_CAST(((uint16_t)x) >> 0)
-#define BE32(x) BYTE_CAST(((uint32)x) >> 24), BYTE_CAST(((uint32)x) >> 16), \
- BYTE_CAST(((uint32)x) >> 8), BYTE_CAST(((uint32)x) >> 0)
+#define BE32(x) \
+ BYTE_CAST(((uint32_t)x) >> 24), BYTE_CAST(((uint32_t)x) >> 16), \
+ BYTE_CAST(((uint32_t)x) >> 8), BYTE_CAST(((uint32_t)x) >> 0)
-#define BE64(x) BYTE_CAST(((uint64)x) >> 56), BYTE_CAST(((uint64)x) >> 48), \
- BYTE_CAST(((uint64)x) >> 40), BYTE_CAST(((uint64)x) >> 32), \
- BYTE_CAST(((uint64)x) >> 24), BYTE_CAST(((uint64)x) >> 16), \
- BYTE_CAST(((uint64)x) >> 8), BYTE_CAST(((uint64)x) >> 0)
+#define BE64(x) \
+ BYTE_CAST(((uint64_t)x) >> 56), BYTE_CAST(((uint64_t)x) >> 48), \
+ BYTE_CAST(((uint64_t)x) >> 40), BYTE_CAST(((uint64_t)x) >> 32), \
+ BYTE_CAST(((uint64_t)x) >> 24), BYTE_CAST(((uint64_t)x) >> 16), \
+ BYTE_CAST(((uint64_t)x) >> 8), BYTE_CAST(((uint64_t)x) >> 0)
// Declare a N-bit integer as a this-endian (local machine) sequence of bytes
#ifndef BIG_ENDIAN
diff --git a/webrtc/base/thread.cc b/webrtc/base/thread.cc
index 48a9144..8ab381f 100644
--- a/webrtc/base/thread.cc
+++ b/webrtc/base/thread.cc
@@ -385,7 +385,7 @@
Join();
}
-void Thread::Send(MessageHandler *phandler, uint32 id, MessageData *pdata) {
+void Thread::Send(MessageHandler* phandler, uint32_t id, MessageData* pdata) {
if (fStop_)
return;
@@ -495,7 +495,8 @@
TRACE_EVENT_END0("webrtc", "Thread::Invoke");
}
-void Thread::Clear(MessageHandler *phandler, uint32 id,
+void Thread::Clear(MessageHandler* phandler,
+ uint32_t id,
MessageList* removed) {
CritScope cs(&crit_);
@@ -524,7 +525,7 @@
}
bool Thread::ProcessMessages(int cmsLoop) {
- uint32 msEnd = (kForever == cmsLoop) ? 0 : TimeAfter(cmsLoop);
+ uint32_t msEnd = (kForever == cmsLoop) ? 0 : TimeAfter(cmsLoop);
int cmsNext = cmsLoop;
while (true) {
diff --git a/webrtc/base/thread.h b/webrtc/base/thread.h
index 1a04de5..9cbe8ec 100644
--- a/webrtc/base/thread.h
+++ b/webrtc/base/thread.h
@@ -155,8 +155,9 @@
// ProcessMessages occasionally.
virtual void Run();
- virtual void Send(MessageHandler *phandler, uint32 id = 0,
- MessageData *pdata = NULL);
+ virtual void Send(MessageHandler* phandler,
+ uint32_t id = 0,
+ MessageData* pdata = NULL);
// Convenience method to invoke a functor on another thread. Caller must
// provide the |ReturnT| template argument, which cannot (easily) be deduced.
@@ -176,7 +177,7 @@
// From MessageQueue
void Clear(MessageHandler* phandler,
- uint32 id = MQID_ANY,
+ uint32_t id = MQID_ANY,
MessageList* removed = NULL) override;
void ReceiveSends() override;
diff --git a/webrtc/base/thread_unittest.cc b/webrtc/base/thread_unittest.cc
index 7b9481e..e50e45c 100644
--- a/webrtc/base/thread_unittest.cc
+++ b/webrtc/base/thread_unittest.cc
@@ -66,9 +66,9 @@
void OnPacket(AsyncPacketSocket* socket, const char* buf, size_t size,
const SocketAddress& remote_addr,
const PacketTime& packet_time) {
- EXPECT_EQ(size, sizeof(uint32));
- uint32 prev = reinterpret_cast<const uint32*>(buf)[0];
- uint32 result = Next(prev);
+ EXPECT_EQ(size, sizeof(uint32_t));
+ uint32_t prev = reinterpret_cast<const uint32_t*>(buf)[0];
+ uint32_t result = Next(prev);
post_thread_->PostDelayed(200, post_handler_, 0, new TestMessage(result));
}
diff --git a/webrtc/base/timeutils.cc b/webrtc/base/timeutils.cc
index ffaf326..fac5b66 100644
--- a/webrtc/base/timeutils.cc
+++ b/webrtc/base/timeutils.cc
@@ -32,10 +32,10 @@
namespace rtc {
-const uint32 HALF = 0x80000000;
+const uint32_t HALF = 0x80000000;
-uint64 TimeNanos() {
- int64 ticks = 0;
+uint64_t TimeNanos() {
+ int64_t ticks = 0;
#if defined(WEBRTC_MAC)
static mach_timebase_info_data_t timebase;
if (timebase.denom == 0) {
@@ -52,11 +52,11 @@
// TODO: Do we need to handle the case when CLOCK_MONOTONIC
// is not supported?
clock_gettime(CLOCK_MONOTONIC, &ts);
- ticks = kNumNanosecsPerSec * static_cast<int64>(ts.tv_sec) +
- static_cast<int64>(ts.tv_nsec);
+ ticks = kNumNanosecsPerSec * static_cast<int64_t>(ts.tv_sec) +
+ static_cast<int64_t>(ts.tv_nsec);
#elif defined(WEBRTC_WIN)
static volatile LONG last_timegettime = 0;
- static volatile int64 num_wrap_timegettime = 0;
+ static volatile int64_t num_wrap_timegettime = 0;
volatile LONG* last_timegettime_ptr = &last_timegettime;
DWORD now = timeGetTime();
// Atomically update the last gotten time
@@ -78,16 +78,16 @@
return ticks;
}
-uint32 Time() {
- return static_cast<uint32>(TimeNanos() / kNumNanosecsPerMillisec);
+uint32_t Time() {
+ return static_cast<uint32_t>(TimeNanos() / kNumNanosecsPerMillisec);
}
-uint64 TimeMicros() {
- return static_cast<uint64>(TimeNanos() / kNumNanosecsPerMicrosec);
+uint64_t TimeMicros() {
+ return static_cast<uint64_t>(TimeNanos() / kNumNanosecsPerMicrosec);
}
#if defined(WEBRTC_WIN)
-static const uint64 kFileTimeToUnixTimeEpochOffset = 116444736000000000ULL;
+static const uint64_t kFileTimeToUnixTimeEpochOffset = 116444736000000000ULL;
struct timeval {
long tv_sec, tv_usec; // NOLINT
@@ -105,7 +105,7 @@
li.HighPart = ft.dwHighDateTime;
// Convert to seconds and microseconds since Unix time Epoch.
- int64 micros = (li.QuadPart - kFileTimeToUnixTimeEpochOffset) / 10;
+ int64_t micros = (li.QuadPart - kFileTimeToUnixTimeEpochOffset) / 10;
tv->tv_sec = static_cast<long>(micros / kNumMicrosecsPerSec); // NOLINT
tv->tv_usec = static_cast<long>(micros % kNumMicrosecsPerSec); // NOLINT
@@ -135,13 +135,13 @@
*microseconds = timeval.tv_usec;
}
-uint32 TimeAfter(int32 elapsed) {
+uint32_t TimeAfter(int32_t elapsed) {
RTC_DCHECK_GE(elapsed, 0);
- RTC_DCHECK_LT(static_cast<uint32>(elapsed), HALF);
+ RTC_DCHECK_LT(static_cast<uint32_t>(elapsed), HALF);
return Time() + elapsed;
}
-bool TimeIsBetween(uint32 earlier, uint32 middle, uint32 later) {
+bool TimeIsBetween(uint32_t earlier, uint32_t middle, uint32_t later) {
if (earlier <= later) {
return ((earlier <= middle) && (middle <= later));
} else {
@@ -149,27 +149,27 @@
}
}
-bool TimeIsLaterOrEqual(uint32 earlier, uint32 later) {
+bool TimeIsLaterOrEqual(uint32_t earlier, uint32_t later) {
#if EFFICIENT_IMPLEMENTATION
- int32 diff = later - earlier;
- return (diff >= 0 && static_cast<uint32>(diff) < HALF);
+ int32_t diff = later - earlier;
+ return (diff >= 0 && static_cast<uint32_t>(diff) < HALF);
#else
const bool later_or_equal = TimeIsBetween(earlier, later, earlier + HALF);
return later_or_equal;
#endif
}
-bool TimeIsLater(uint32 earlier, uint32 later) {
+bool TimeIsLater(uint32_t earlier, uint32_t later) {
#if EFFICIENT_IMPLEMENTATION
- int32 diff = later - earlier;
- return (diff > 0 && static_cast<uint32>(diff) < HALF);
+ int32_t diff = later - earlier;
+ return (diff > 0 && static_cast<uint32_t>(diff) < HALF);
#else
const bool earlier_or_equal = TimeIsBetween(later, earlier, later + HALF);
return !earlier_or_equal;
#endif
}
-int32 TimeDiff(uint32 later, uint32 earlier) {
+int32_t TimeDiff(uint32_t later, uint32_t earlier) {
#if EFFICIENT_IMPLEMENTATION
return later - earlier;
#else
@@ -193,7 +193,7 @@
TimestampWrapAroundHandler::TimestampWrapAroundHandler()
: last_ts_(0), num_wrap_(0) {}
-int64 TimestampWrapAroundHandler::Unwrap(uint32 ts) {
+int64_t TimestampWrapAroundHandler::Unwrap(uint32_t ts) {
if (ts < last_ts_) {
if (last_ts_ > 0xf0000000 && ts < 0x0fffffff) {
++num_wrap_;
diff --git a/webrtc/base/timeutils.h b/webrtc/base/timeutils.h
index ca041a7..bdeccc3 100644
--- a/webrtc/base/timeutils.h
+++ b/webrtc/base/timeutils.h
@@ -17,66 +17,68 @@
namespace rtc {
-static const int64 kNumMillisecsPerSec = INT64_C(1000);
-static const int64 kNumMicrosecsPerSec = INT64_C(1000000);
-static const int64 kNumNanosecsPerSec = INT64_C(1000000000);
+static const int64_t kNumMillisecsPerSec = INT64_C(1000);
+static const int64_t kNumMicrosecsPerSec = INT64_C(1000000);
+static const int64_t kNumNanosecsPerSec = INT64_C(1000000000);
-static const int64 kNumMicrosecsPerMillisec = kNumMicrosecsPerSec /
- kNumMillisecsPerSec;
-static const int64 kNumNanosecsPerMillisec = kNumNanosecsPerSec /
- kNumMillisecsPerSec;
-static const int64 kNumNanosecsPerMicrosec = kNumNanosecsPerSec /
- kNumMicrosecsPerSec;
+static const int64_t kNumMicrosecsPerMillisec =
+ kNumMicrosecsPerSec / kNumMillisecsPerSec;
+static const int64_t kNumNanosecsPerMillisec =
+ kNumNanosecsPerSec / kNumMillisecsPerSec;
+static const int64_t kNumNanosecsPerMicrosec =
+ kNumNanosecsPerSec / kNumMicrosecsPerSec;
// January 1970, in NTP milliseconds.
-static const int64 kJan1970AsNtpMillisecs = INT64_C(2208988800000);
+static const int64_t kJan1970AsNtpMillisecs = INT64_C(2208988800000);
-typedef uint32 TimeStamp;
+typedef uint32_t TimeStamp;
// Returns the current time in milliseconds.
-uint32 Time();
+uint32_t Time();
// Returns the current time in microseconds.
-uint64 TimeMicros();
+uint64_t TimeMicros();
// Returns the current time in nanoseconds.
-uint64 TimeNanos();
+uint64_t TimeNanos();
// Stores current time in *tm and microseconds in *microseconds.
void CurrentTmTime(struct tm *tm, int *microseconds);
// Returns a future timestamp, 'elapsed' milliseconds from now.
-uint32 TimeAfter(int32 elapsed);
+uint32_t TimeAfter(int32_t elapsed);
// Comparisons between time values, which can wrap around.
-bool TimeIsBetween(uint32 earlier, uint32 middle, uint32 later); // Inclusive
-bool TimeIsLaterOrEqual(uint32 earlier, uint32 later); // Inclusive
-bool TimeIsLater(uint32 earlier, uint32 later); // Exclusive
+bool TimeIsBetween(uint32_t earlier,
+ uint32_t middle,
+ uint32_t later); // Inclusive
+bool TimeIsLaterOrEqual(uint32_t earlier, uint32_t later); // Inclusive
+bool TimeIsLater(uint32_t earlier, uint32_t later); // Exclusive
// Returns the later of two timestamps.
-inline uint32 TimeMax(uint32 ts1, uint32 ts2) {
+inline uint32_t TimeMax(uint32_t ts1, uint32_t ts2) {
return TimeIsLaterOrEqual(ts1, ts2) ? ts2 : ts1;
}
// Returns the earlier of two timestamps.
-inline uint32 TimeMin(uint32 ts1, uint32 ts2) {
+inline uint32_t TimeMin(uint32_t ts1, uint32_t ts2) {
return TimeIsLaterOrEqual(ts1, ts2) ? ts1 : ts2;
}
// Number of milliseconds that would elapse between 'earlier' and 'later'
// timestamps. The value is negative if 'later' occurs before 'earlier'.
-int32 TimeDiff(uint32 later, uint32 earlier);
+int32_t TimeDiff(uint32_t later, uint32_t earlier);
// The number of milliseconds that have elapsed since 'earlier'.
-inline int32 TimeSince(uint32 earlier) {
+inline int32_t TimeSince(uint32_t earlier) {
return TimeDiff(Time(), earlier);
}
// The number of milliseconds that will elapse between now and 'later'.
-inline int32 TimeUntil(uint32 later) {
+inline int32_t TimeUntil(uint32_t later) {
return TimeDiff(later, Time());
}
// Converts a unix timestamp in nanoseconds to an NTP timestamp in ms.
-inline int64 UnixTimestampNanosecsToNtpMillisecs(int64 unix_ts_ns) {
+inline int64_t UnixTimestampNanosecsToNtpMillisecs(int64_t unix_ts_ns) {
return unix_ts_ns / kNumNanosecsPerMillisec + kJan1970AsNtpMillisecs;
}
@@ -84,11 +86,11 @@
public:
TimestampWrapAroundHandler();
- int64 Unwrap(uint32 ts);
+ int64_t Unwrap(uint32_t ts);
private:
- uint32 last_ts_;
- int64 num_wrap_;
+ uint32_t last_ts_;
+ int64_t num_wrap_;
};
} // namespace rtc
diff --git a/webrtc/base/timeutils_unittest.cc b/webrtc/base/timeutils_unittest.cc
index 087fb0c..d1b9ad4 100644
--- a/webrtc/base/timeutils_unittest.cc
+++ b/webrtc/base/timeutils_unittest.cc
@@ -16,9 +16,9 @@
namespace rtc {
TEST(TimeTest, TimeInMs) {
- uint32 ts_earlier = Time();
+ uint32_t ts_earlier = Time();
Thread::SleepMs(100);
- uint32 ts_now = Time();
+ uint32_t ts_now = Time();
// Allow for the thread to wakeup ~20ms early.
EXPECT_GE(ts_now, ts_earlier + 80);
// Make sure the Time is not returning in smaller unit like microseconds.
@@ -152,8 +152,8 @@
};
TEST_F(TimestampWrapAroundHandlerTest, Unwrap) {
- uint32 ts = 0xfffffff2;
- int64 unwrapped_ts = ts;
+ uint32_t ts = 0xfffffff2;
+ int64_t unwrapped_ts = ts;
EXPECT_EQ(ts, wraparound_handler_.Unwrap(ts));
ts = 2;
unwrapped_ts += 0x10;
diff --git a/webrtc/base/unixfilesystem.cc b/webrtc/base/unixfilesystem.cc
index 081d561..30d6e78 100644
--- a/webrtc/base/unixfilesystem.cc
+++ b/webrtc/base/unixfilesystem.cc
@@ -502,7 +502,8 @@
#endif
}
-bool UnixFilesystem::GetDiskFreeSpace(const Pathname& path, int64 *freebytes) {
+bool UnixFilesystem::GetDiskFreeSpace(const Pathname& path,
+ int64_t* freebytes) {
#ifdef __native_client__
return false;
#else // __native_client__
@@ -526,9 +527,9 @@
return false;
#endif // WEBRTC_ANDROID
#if defined(WEBRTC_LINUX)
- *freebytes = static_cast<int64>(vfs.f_bsize) * vfs.f_bavail;
+ *freebytes = static_cast<int64_t>(vfs.f_bsize) * vfs.f_bavail;
#elif defined(WEBRTC_MAC)
- *freebytes = static_cast<int64>(vfs.f_frsize) * vfs.f_bavail;
+ *freebytes = static_cast<int64_t>(vfs.f_frsize) * vfs.f_bavail;
#endif
return true;
diff --git a/webrtc/base/unixfilesystem.h b/webrtc/base/unixfilesystem.h
index e220911..dbfbaf0 100644
--- a/webrtc/base/unixfilesystem.h
+++ b/webrtc/base/unixfilesystem.h
@@ -107,7 +107,7 @@
// Get a temporary folder that is unique to the current user and application.
bool GetAppTempFolder(Pathname* path) override;
- bool GetDiskFreeSpace(const Pathname& path, int64* freebytes) override;
+ bool GetDiskFreeSpace(const Pathname& path, int64_t* freebytes) override;
// Returns the absolute path of the current directory.
Pathname GetCurrentDirectory() override;
diff --git a/webrtc/base/virtualsocket_unittest.cc b/webrtc/base/virtualsocket_unittest.cc
index a656691..694b154 100644
--- a/webrtc/base/virtualsocket_unittest.cc
+++ b/webrtc/base/virtualsocket_unittest.cc
@@ -27,15 +27,18 @@
// Sends at a constant rate but with random packet sizes.
struct Sender : public MessageHandler {
- Sender(Thread* th, AsyncSocket* s, uint32 rt)
- : thread(th), socket(new AsyncUDPSocket(s)),
- done(false), rate(rt), count(0) {
+ Sender(Thread* th, AsyncSocket* s, uint32_t rt)
+ : thread(th),
+ socket(new AsyncUDPSocket(s)),
+ done(false),
+ rate(rt),
+ count(0) {
last_send = rtc::Time();
thread->PostDelayed(NextDelay(), this, 1);
}
- uint32 NextDelay() {
- uint32 size = (rand() % 4096) + 1;
+ uint32_t NextDelay() {
+ uint32_t size = (rand() % 4096) + 1;
return 1000 * size / rate;
}
@@ -45,11 +48,11 @@
if (done)
return;
- uint32 cur_time = rtc::Time();
- uint32 delay = cur_time - last_send;
- uint32 size = rate * delay / 1000;
- size = std::min<uint32>(size, 4096);
- size = std::max<uint32>(size, sizeof(uint32));
+ uint32_t cur_time = rtc::Time();
+ uint32_t delay = cur_time - last_send;
+ uint32_t size = rate * delay / 1000;
+ size = std::min<uint32_t>(size, 4096);
+ size = std::max<uint32_t>(size, sizeof(uint32_t));
count += size;
memcpy(dummy, &cur_time, sizeof(cur_time));
@@ -63,16 +66,23 @@
scoped_ptr<AsyncUDPSocket> socket;
rtc::PacketOptions options;
bool done;
- uint32 rate; // bytes per second
- uint32 count;
- uint32 last_send;
+ uint32_t rate; // bytes per second
+ uint32_t count;
+ uint32_t last_send;
char dummy[4096];
};
struct Receiver : public MessageHandler, public sigslot::has_slots<> {
- Receiver(Thread* th, AsyncSocket* s, uint32 bw)
- : thread(th), socket(new AsyncUDPSocket(s)), bandwidth(bw), done(false),
- count(0), sec_count(0), sum(0), sum_sq(0), samples(0) {
+ Receiver(Thread* th, AsyncSocket* s, uint32_t bw)
+ : thread(th),
+ socket(new AsyncUDPSocket(s)),
+ bandwidth(bw),
+ done(false),
+ count(0),
+ sec_count(0),
+ sum(0),
+ sum_sq(0),
+ samples(0) {
socket->SignalReadPacket.connect(this, &Receiver::OnReadPacket);
thread->PostDelayed(1000, this, 1);
}
@@ -90,9 +100,9 @@
count += size;
sec_count += size;
- uint32 send_time = *reinterpret_cast<const uint32*>(data);
- uint32 recv_time = rtc::Time();
- uint32 delay = recv_time - send_time;
+ uint32_t send_time = *reinterpret_cast<const uint32_t*>(data);
+ uint32_t recv_time = rtc::Time();
+ uint32_t delay = recv_time - send_time;
sum += delay;
sum_sq += delay * delay;
samples += 1;
@@ -114,13 +124,13 @@
Thread* thread;
scoped_ptr<AsyncUDPSocket> socket;
- uint32 bandwidth;
+ uint32_t bandwidth;
bool done;
size_t count;
size_t sec_count;
double sum;
double sum_sq;
- uint32 samples;
+ uint32_t samples;
};
class VirtualSocketServerTest : public testing::Test {
@@ -143,8 +153,8 @@
} else if (post_ip.family() == AF_INET6) {
in6_addr post_ip6 = post_ip.ipv6_address();
in6_addr pre_ip6 = pre_ip.ipv6_address();
- uint32* post_as_ints = reinterpret_cast<uint32*>(&post_ip6.s6_addr);
- uint32* pre_as_ints = reinterpret_cast<uint32*>(&pre_ip6.s6_addr);
+ uint32_t* post_as_ints = reinterpret_cast<uint32_t*>(&post_ip6.s6_addr);
+ uint32_t* pre_as_ints = reinterpret_cast<uint32_t*>(&pre_ip6.s6_addr);
EXPECT_EQ(post_as_ints[3], pre_as_ints[3]);
}
}
@@ -620,8 +630,8 @@
}
// Next, deliver packets at random intervals
- const uint32 mean = 50;
- const uint32 stddev = 50;
+ const uint32_t mean = 50;
+ const uint32_t stddev = 50;
ss_->set_delay_mean(mean);
ss_->set_delay_stddev(stddev);
@@ -654,7 +664,7 @@
EXPECT_EQ(recv_socket->GetLocalAddress().family(), initial_addr.family());
ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
- uint32 bandwidth = 64 * 1024;
+ uint32_t bandwidth = 64 * 1024;
ss_->set_bandwidth(bandwidth);
Thread* pthMain = Thread::Current();
@@ -679,8 +689,8 @@
LOG(LS_VERBOSE) << "seed = " << seed;
srand(static_cast<unsigned int>(seed));
- const uint32 mean = 2000;
- const uint32 stddev = 500;
+ const uint32_t mean = 2000;
+ const uint32_t stddev = 500;
ss_->set_delay_mean(mean);
ss_->set_delay_stddev(stddev);
@@ -1008,16 +1018,16 @@
}
TEST_F(VirtualSocketServerTest, CreatesStandardDistribution) {
- const uint32 kTestMean[] = { 10, 100, 333, 1000 };
+ const uint32_t kTestMean[] = {10, 100, 333, 1000};
const double kTestDev[] = { 0.25, 0.1, 0.01 };
// TODO: The current code only works for 1000 data points or more.
- const uint32 kTestSamples[] = { /*10, 100,*/ 1000 };
+ const uint32_t kTestSamples[] = {/*10, 100,*/ 1000};
for (size_t midx = 0; midx < ARRAY_SIZE(kTestMean); ++midx) {
for (size_t didx = 0; didx < ARRAY_SIZE(kTestDev); ++didx) {
for (size_t sidx = 0; sidx < ARRAY_SIZE(kTestSamples); ++sidx) {
ASSERT_LT(0u, kTestSamples[sidx]);
- const uint32 kStdDev =
- static_cast<uint32>(kTestDev[didx] * kTestMean[midx]);
+ const uint32_t kStdDev =
+ static_cast<uint32_t>(kTestDev[didx] * kTestMean[midx]);
VirtualSocketServer::Function* f =
VirtualSocketServer::CreateDistribution(kTestMean[midx],
kStdDev,
@@ -1025,12 +1035,12 @@
ASSERT_TRUE(NULL != f);
ASSERT_EQ(kTestSamples[sidx], f->size());
double sum = 0;
- for (uint32 i = 0; i < f->size(); ++i) {
+ for (uint32_t i = 0; i < f->size(); ++i) {
sum += (*f)[i].second;
}
const double mean = sum / f->size();
double sum_sq_dev = 0;
- for (uint32 i = 0; i < f->size(); ++i) {
+ for (uint32_t i = 0; i < f->size(); ++i) {
double dev = (*f)[i].second - mean;
sum_sq_dev += dev * dev;
}
diff --git a/webrtc/base/virtualsocketserver.cc b/webrtc/base/virtualsocketserver.cc
index 4568bf2..867aeec 100644
--- a/webrtc/base/virtualsocketserver.cc
+++ b/webrtc/base/virtualsocketserver.cc
@@ -37,15 +37,16 @@
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2
} } };
-const uint16 kFirstEphemeralPort = 49152;
-const uint16 kLastEphemeralPort = 65535;
-const uint16 kEphemeralPortCount = kLastEphemeralPort - kFirstEphemeralPort + 1;
-const uint32 kDefaultNetworkCapacity = 64 * 1024;
-const uint32 kDefaultTcpBufferSize = 32 * 1024;
+const uint16_t kFirstEphemeralPort = 49152;
+const uint16_t kLastEphemeralPort = 65535;
+const uint16_t kEphemeralPortCount =
+ kLastEphemeralPort - kFirstEphemeralPort + 1;
+const uint32_t kDefaultNetworkCapacity = 64 * 1024;
+const uint32_t kDefaultTcpBufferSize = 32 * 1024;
-const uint32 UDP_HEADER_SIZE = 28; // IP + UDP headers
-const uint32 TCP_HEADER_SIZE = 40; // IP + TCP headers
-const uint32 TCP_MSS = 1400; // Maximum segment size
+const uint32_t UDP_HEADER_SIZE = 28; // IP + UDP headers
+const uint32_t TCP_HEADER_SIZE = 40; // IP + TCP headers
+const uint32_t TCP_MSS = 1400; // Maximum segment size
// Note: The current algorithm doesn't work for sample sizes smaller than this.
const int NUM_SAMPLES = 1000;
@@ -375,7 +376,7 @@
return 0; // 0 is success to emulate setsockopt()
}
-int VirtualSocket::EstimateMTU(uint16* mtu) {
+int VirtualSocket::EstimateMTU(uint16_t* mtu) {
if (CS_CONNECTED != state_)
return ENOTCONN;
else
@@ -532,15 +533,15 @@
return next_ip;
} else if (family == AF_INET6) {
IPAddress next_ip(next_ipv6_);
- uint32* as_ints = reinterpret_cast<uint32*>(&next_ipv6_.s6_addr);
+ uint32_t* as_ints = reinterpret_cast<uint32_t*>(&next_ipv6_.s6_addr);
as_ints[3] += 1;
return next_ip;
}
return IPAddress();
}
-uint16 VirtualSocketServer::GetNextPort() {
- uint16 port = next_port_;
+uint16_t VirtualSocketServer::GetNextPort() {
+ uint16_t port = next_port_;
if (next_port_ < kLastEphemeralPort) {
++next_port_;
} else {
@@ -602,7 +603,7 @@
return !msg_queue_->IsQuitting();
}
-void VirtualSocketServer::SetNextPortForTesting(uint16 port) {
+void VirtualSocketServer::SetNextPortForTesting(uint16_t port) {
next_port_ = port;
}
@@ -731,7 +732,7 @@
int VirtualSocketServer::Connect(VirtualSocket* socket,
const SocketAddress& remote_addr,
bool use_delay) {
- uint32 delay = use_delay ? GetRandomTransitDelay() : 0;
+ uint32_t delay = use_delay ? GetRandomTransitDelay() : 0;
VirtualSocket* remote = LookupBinding(remote_addr);
if (!CanInteractWith(socket, remote)) {
LOG(LS_INFO) << "Address family mismatch between "
@@ -790,7 +791,7 @@
CritScope cs(&socket->crit_);
- uint32 cur_time = Time();
+ uint32_t cur_time = Time();
PurgeNetworkPackets(socket, cur_time);
// Determine whether we have enough bandwidth to accept this packet. To do
@@ -830,7 +831,7 @@
CritScope cs(&socket->crit_);
- uint32 cur_time = Time();
+ uint32_t cur_time = Time();
PurgeNetworkPackets(socket, cur_time);
while (true) {
@@ -865,7 +866,7 @@
void VirtualSocketServer::AddPacketToNetwork(VirtualSocket* sender,
VirtualSocket* recipient,
- uint32 cur_time,
+ uint32_t cur_time,
const char* data,
size_t data_size,
size_t header_size,
@@ -874,12 +875,12 @@
entry.size = data_size + header_size;
sender->network_size_ += entry.size;
- uint32 send_delay = SendDelay(static_cast<uint32>(sender->network_size_));
+ uint32_t send_delay = SendDelay(static_cast<uint32_t>(sender->network_size_));
entry.done_time = cur_time + send_delay;
sender->network_.push_back(entry);
// Find the delay for crossing the many virtual hops of the network.
- uint32 transit_delay = GetRandomTransitDelay();
+ uint32_t transit_delay = GetRandomTransitDelay();
// When the incoming packet is from a binding of the any address, translate it
// to the default route here such that the recipient will see the default
@@ -893,7 +894,7 @@
// Post the packet as a message to be delivered (on our own thread)
Packet* p = new Packet(data, data_size, sender_addr);
- uint32 ts = TimeAfter(send_delay + transit_delay);
+ uint32_t ts = TimeAfter(send_delay + transit_delay);
if (ordered) {
// Ensure that new packets arrive after previous ones
// TODO: consider ordering on a per-socket basis, since this
@@ -905,7 +906,7 @@
}
void VirtualSocketServer::PurgeNetworkPackets(VirtualSocket* socket,
- uint32 cur_time) {
+ uint32_t cur_time) {
while (!socket->network_.empty() &&
(socket->network_.front().done_time <= cur_time)) {
ASSERT(socket->network_size_ >= socket->network_.front().size);
@@ -914,7 +915,7 @@
}
}
-uint32 VirtualSocketServer::SendDelay(uint32 size) {
+uint32_t VirtualSocketServer::SendDelay(uint32_t size) {
if (bandwidth_ == 0)
return 0;
else
@@ -925,14 +926,14 @@
void PrintFunction(std::vector<std::pair<double, double> >* f) {
return;
double sum = 0;
- for (uint32 i = 0; i < f->size(); ++i) {
+ for (uint32_t i = 0; i < f->size(); ++i) {
std::cout << (*f)[i].first << '\t' << (*f)[i].second << std::endl;
sum += (*f)[i].second;
}
if (!f->empty()) {
const double mean = sum / f->size();
double sum_sq_dev = 0;
- for (uint32 i = 0; i < f->size(); ++i) {
+ for (uint32_t i = 0; i < f->size(); ++i) {
double dev = (*f)[i].second - mean;
sum_sq_dev += dev * dev;
}
@@ -970,7 +971,9 @@
#endif
VirtualSocketServer::Function* VirtualSocketServer::CreateDistribution(
- uint32 mean, uint32 stddev, uint32 samples) {
+ uint32_t mean,
+ uint32_t stddev,
+ uint32_t samples) {
Function* f = new Function();
if (0 == stddev) {
@@ -981,7 +984,7 @@
start = mean - 4 * static_cast<double>(stddev);
double end = mean + 4 * static_cast<double>(stddev);
- for (uint32 i = 0; i < samples; i++) {
+ for (uint32_t i = 0; i < samples; i++) {
double x = start + (end - start) * i / (samples - 1);
double y = Normal(x, mean, stddev);
f->push_back(Point(x, y));
@@ -990,11 +993,11 @@
return Resample(Invert(Accumulate(f)), 0, 1, samples);
}
-uint32 VirtualSocketServer::GetRandomTransitDelay() {
+uint32_t VirtualSocketServer::GetRandomTransitDelay() {
size_t index = rand() % delay_dist_->size();
double delay = (*delay_dist_)[index].second;
//LOG_F(LS_INFO) << "random[" << index << "] = " << delay;
- return static_cast<uint32>(delay);
+ return static_cast<uint32_t>(delay);
}
struct FunctionDomainCmp {
@@ -1031,8 +1034,10 @@
return f;
}
-VirtualSocketServer::Function* VirtualSocketServer::Resample(
- Function* f, double x1, double x2, uint32 samples) {
+VirtualSocketServer::Function* VirtualSocketServer::Resample(Function* f,
+ double x1,
+ double x2,
+ uint32_t samples) {
Function* g = new Function();
for (size_t i = 0; i < samples; i++) {
diff --git a/webrtc/base/virtualsocketserver.h b/webrtc/base/virtualsocketserver.h
index f1f5d6d..daf0145 100644
--- a/webrtc/base/virtualsocketserver.h
+++ b/webrtc/base/virtualsocketserver.h
@@ -45,39 +45,35 @@
// Limits the network bandwidth (maximum bytes per second). Zero means that
// all sends occur instantly. Defaults to 0.
- uint32 bandwidth() const { return bandwidth_; }
- void set_bandwidth(uint32 bandwidth) { bandwidth_ = bandwidth; }
+ uint32_t bandwidth() const { return bandwidth_; }
+ void set_bandwidth(uint32_t bandwidth) { bandwidth_ = bandwidth; }
// Limits the amount of data which can be in flight on the network without
// packet loss (on a per sender basis). Defaults to 64 KB.
- uint32 network_capacity() const { return network_capacity_; }
- void set_network_capacity(uint32 capacity) {
- network_capacity_ = capacity;
- }
+ uint32_t network_capacity() const { return network_capacity_; }
+ void set_network_capacity(uint32_t capacity) { network_capacity_ = capacity; }
// The amount of data which can be buffered by tcp on the sender's side
- uint32 send_buffer_capacity() const { return send_buffer_capacity_; }
- void set_send_buffer_capacity(uint32 capacity) {
+ uint32_t send_buffer_capacity() const { return send_buffer_capacity_; }
+ void set_send_buffer_capacity(uint32_t capacity) {
send_buffer_capacity_ = capacity;
}
// The amount of data which can be buffered by tcp on the receiver's side
- uint32 recv_buffer_capacity() const { return recv_buffer_capacity_; }
- void set_recv_buffer_capacity(uint32 capacity) {
+ uint32_t recv_buffer_capacity() const { return recv_buffer_capacity_; }
+ void set_recv_buffer_capacity(uint32_t capacity) {
recv_buffer_capacity_ = capacity;
}
// Controls the (transit) delay for packets sent in the network. This does
// not inclue the time required to sit in the send queue. Both of these
// values are measured in milliseconds. Defaults to no delay.
- uint32 delay_mean() const { return delay_mean_; }
- uint32 delay_stddev() const { return delay_stddev_; }
- uint32 delay_samples() const { return delay_samples_; }
- void set_delay_mean(uint32 delay_mean) { delay_mean_ = delay_mean; }
- void set_delay_stddev(uint32 delay_stddev) {
- delay_stddev_ = delay_stddev;
- }
- void set_delay_samples(uint32 delay_samples) {
+ uint32_t delay_mean() const { return delay_mean_; }
+ uint32_t delay_stddev() const { return delay_stddev_; }
+ uint32_t delay_samples() const { return delay_samples_; }
+ void set_delay_mean(uint32_t delay_mean) { delay_mean_ = delay_mean; }
+ void set_delay_stddev(uint32_t delay_stddev) { delay_stddev_ = delay_stddev; }
+ void set_delay_samples(uint32_t delay_samples) {
delay_samples_ = delay_samples;
}
@@ -108,8 +104,9 @@
typedef std::pair<double, double> Point;
typedef std::vector<Point> Function;
- static Function* CreateDistribution(uint32 mean, uint32 stddev,
- uint32 samples);
+ static Function* CreateDistribution(uint32_t mean,
+ uint32_t stddev,
+ uint32_t samples);
// Similar to Thread::ProcessMessages, but it only processes messages until
// there are no immediate messages or pending network traffic. Returns false
@@ -117,7 +114,7 @@
bool ProcessMessagesUntilIdle();
// Sets the next port number to use for testing.
- void SetNextPortForTesting(uint16 port);
+ void SetNextPortForTesting(uint16_t port);
// Close a pair of Tcp connections by addresses. Both connections will have
// its own OnClose invoked.
@@ -127,7 +124,7 @@
protected:
// Returns a new IP not used before in this network.
IPAddress GetNextIP(int family);
- uint16 GetNextPort();
+ uint16_t GetNextPort();
VirtualSocket* CreateSocketInternal(int family, int type);
@@ -169,24 +166,31 @@
void SendTcp(VirtualSocket* socket);
// Places a packet on the network.
- void AddPacketToNetwork(VirtualSocket* socket, VirtualSocket* recipient,
- uint32 cur_time, const char* data, size_t data_size,
- size_t header_size, bool ordered);
+ void AddPacketToNetwork(VirtualSocket* socket,
+ VirtualSocket* recipient,
+ uint32_t cur_time,
+ const char* data,
+ size_t data_size,
+ size_t header_size,
+ bool ordered);
// Removes stale packets from the network
- void PurgeNetworkPackets(VirtualSocket* socket, uint32 cur_time);
+ void PurgeNetworkPackets(VirtualSocket* socket, uint32_t cur_time);
// Computes the number of milliseconds required to send a packet of this size.
- uint32 SendDelay(uint32 size);
+ uint32_t SendDelay(uint32_t size);
// Returns a random transit delay chosen from the appropriate distribution.
- uint32 GetRandomTransitDelay();
+ uint32_t GetRandomTransitDelay();
// Basic operations on functions. Those that return a function also take
// ownership of the function given (and hence, may modify or delete it).
static Function* Accumulate(Function* f);
static Function* Invert(Function* f);
- static Function* Resample(Function* f, double x1, double x2, uint32 samples);
+ static Function* Resample(Function* f,
+ double x1,
+ double x2,
+ uint32_t samples);
static double Evaluate(Function* f, double x);
// NULL out our message queue if it goes away. Necessary in the case where
@@ -222,23 +226,23 @@
bool server_owned_;
MessageQueue* msg_queue_;
bool stop_on_idle_;
- uint32 network_delay_;
+ uint32_t network_delay_;
in_addr next_ipv4_;
in6_addr next_ipv6_;
- uint16 next_port_;
+ uint16_t next_port_;
AddressMap* bindings_;
ConnectionMap* connections_;
IPAddress default_route_v4_;
IPAddress default_route_v6_;
- uint32 bandwidth_;
- uint32 network_capacity_;
- uint32 send_buffer_capacity_;
- uint32 recv_buffer_capacity_;
- uint32 delay_mean_;
- uint32 delay_stddev_;
- uint32 delay_samples_;
+ uint32_t bandwidth_;
+ uint32_t network_capacity_;
+ uint32_t send_buffer_capacity_;
+ uint32_t recv_buffer_capacity_;
+ uint32_t delay_mean_;
+ uint32_t delay_stddev_;
+ uint32_t delay_samples_;
Function* delay_dist_;
CriticalSection delay_crit_;
@@ -276,7 +280,7 @@
ConnState GetState() const override;
int GetOption(Option opt, int* value) override;
int SetOption(Option opt, int value) override;
- int EstimateMTU(uint16* mtu) override;
+ int EstimateMTU(uint16_t* mtu) override;
void OnMessage(Message* pmsg) override;
bool was_any() { return was_any_; }
@@ -288,7 +292,7 @@
private:
struct NetworkEntry {
size_t size;
- uint32 done_time;
+ uint32_t done_time;
};
typedef std::deque<SocketAddress> ListenQueue;
diff --git a/webrtc/base/win32.cc b/webrtc/base/win32.cc
index 1f32e48..6e09829 100644
--- a/webrtc/base/win32.cc
+++ b/webrtc/base/win32.cc
@@ -82,8 +82,7 @@
if (size < INET6_ADDRSTRLEN) {
return NULL;
}
- const uint16* as_shorts =
- reinterpret_cast<const uint16*>(src);
+ const uint16_t* as_shorts = reinterpret_cast<const uint16_t*>(src);
int runpos[8];
int current = 1;
int max = 0;
@@ -214,8 +213,8 @@
struct in6_addr an_addr;
memset(&an_addr, 0, sizeof(an_addr));
- uint16* addr_cursor = reinterpret_cast<uint16*>(&an_addr.s6_addr[0]);
- uint16* addr_end = reinterpret_cast<uint16*>(&an_addr.s6_addr[16]);
+ uint16_t* addr_cursor = reinterpret_cast<uint16_t*>(&an_addr.s6_addr[0]);
+ uint16_t* addr_end = reinterpret_cast<uint16_t*>(&an_addr.s6_addr[16]);
bool seencompressed = false;
// Addresses that start with "::" (i.e., a run of initial zeros) or
@@ -228,7 +227,7 @@
if (rtc::strchr(addrstart, ".")) {
const char* colon = rtc::strchr(addrstart, "::");
if (colon) {
- uint16 a_short;
+ uint16_t a_short;
int bytesread = 0;
if (sscanf(addrstart, "%hx%n", &a_short, &bytesread) != 1 ||
a_short != 0xFFFF || bytesread != 4) {
@@ -283,7 +282,7 @@
++readcursor;
}
} else {
- uint16 word;
+ uint16_t word;
int bytesread = 0;
if (sscanf(readcursor, "%hx%n", &word, &bytesread) != 1) {
return 0;
@@ -362,7 +361,7 @@
// base date value.
const ULONGLONG RATIO = 10000000;
ULARGE_INTEGER current_ul;
- current_ul.QuadPart = base_ul.QuadPart + static_cast<int64>(ut) * RATIO;
+ current_ul.QuadPart = base_ul.QuadPart + static_cast<int64_t>(ut) * RATIO;
memcpy(ft, ¤t_ul, sizeof(FILETIME));
}
diff --git a/webrtc/base/win32.h b/webrtc/base/win32.h
index 9824f6b..dba9b77 100644
--- a/webrtc/base/win32.h
+++ b/webrtc/base/win32.h
@@ -85,7 +85,7 @@
bool Utf8ToWindowsFilename(const std::string& utf8, std::wstring* filename);
// Convert a FILETIME to a UInt64
-inline uint64 ToUInt64(const FILETIME& ft) {
+inline uint64_t ToUInt64(const FILETIME& ft) {
ULARGE_INTEGER r = {{ft.dwLowDateTime, ft.dwHighDateTime}};
return r.QuadPart;
}
diff --git a/webrtc/base/win32_unittest.cc b/webrtc/base/win32_unittest.cc
index 2bd93ac..15b2614 100644
--- a/webrtc/base/win32_unittest.cc
+++ b/webrtc/base/win32_unittest.cc
@@ -32,7 +32,7 @@
ft.dwHighDateTime = 0xBAADF00D;
ft.dwLowDateTime = 0xFEED3456;
- uint64 expected = 0xBAADF00DFEED3456;
+ uint64_t expected = 0xBAADF00DFEED3456;
EXPECT_EQ(expected, ToUInt64(ft));
}
diff --git a/webrtc/base/win32filesystem.cc b/webrtc/base/win32filesystem.cc
index 9ca4c99..8ac918f 100644
--- a/webrtc/base/win32filesystem.cc
+++ b/webrtc/base/win32filesystem.cc
@@ -379,7 +379,7 @@
}
bool Win32Filesystem::GetDiskFreeSpace(const Pathname& path,
- int64 *free_bytes) {
+ int64_t* free_bytes) {
if (!free_bytes) {
return false;
}
@@ -405,11 +405,11 @@
return false;
}
- int64 total_number_of_bytes; // receives the number of bytes on disk
- int64 total_number_of_free_bytes; // receives the free bytes on disk
+ int64_t total_number_of_bytes; // receives the number of bytes on disk
+ int64_t total_number_of_free_bytes; // receives the free bytes on disk
// make sure things won't change in 64 bit machine
// TODO replace with compile time assert
- ASSERT(sizeof(ULARGE_INTEGER) == sizeof(uint64)); //NOLINT
+ ASSERT(sizeof(ULARGE_INTEGER) == sizeof(uint64_t)); // NOLINT
if (::GetDiskFreeSpaceEx(target_drive,
(PULARGE_INTEGER)free_bytes,
(PULARGE_INTEGER)&total_number_of_bytes,
diff --git a/webrtc/base/win32filesystem.h b/webrtc/base/win32filesystem.h
index 0ae9218..439b2c6 100644
--- a/webrtc/base/win32filesystem.h
+++ b/webrtc/base/win32filesystem.h
@@ -91,7 +91,7 @@
// Get a temporary folder that is unique to the current user and application.
virtual bool GetAppTempFolder(Pathname* path);
- virtual bool GetDiskFreeSpace(const Pathname& path, int64 *free_bytes);
+ virtual bool GetDiskFreeSpace(const Pathname& path, int64_t* free_bytes);
virtual Pathname GetCurrentDirectory();
};
diff --git a/webrtc/base/win32regkey.cc b/webrtc/base/win32regkey.cc
index 1ed0d4e..ccf931c 100644
--- a/webrtc/base/win32regkey.cc
+++ b/webrtc/base/win32regkey.cc
@@ -100,22 +100,22 @@
HRESULT RegKey::SetValue(const wchar_t* full_key_name,
const wchar_t* value_name,
- const uint8* value,
+ const uint8_t* value,
DWORD byte_count) {
ASSERT(full_key_name != NULL);
return SetValueStaticHelper(full_key_name, value_name, REG_BINARY,
- const_cast<uint8*>(value), byte_count);
+ const_cast<uint8_t*>(value), byte_count);
}
HRESULT RegKey::SetValueMultiSZ(const wchar_t* full_key_name,
const wchar_t* value_name,
- const uint8* value,
+ const uint8_t* value,
DWORD byte_count) {
ASSERT(full_key_name != NULL);
return SetValueStaticHelper(full_key_name, value_name, REG_MULTI_SZ,
- const_cast<uint8*>(value), byte_count);
+ const_cast<uint8_t*>(value), byte_count);
}
HRESULT RegKey::GetValue(const wchar_t* full_key_name,
@@ -208,7 +208,7 @@
HRESULT RegKey::GetValue(const wchar_t* full_key_name,
const wchar_t* value_name,
- uint8** value,
+ uint8_t** value,
DWORD* byte_count) {
ASSERT(full_key_name != NULL);
ASSERT(value != NULL);
@@ -407,11 +407,11 @@
hr = key.SetValue(value_name, static_cast<const wchar_t*>(value));
break;
case REG_BINARY:
- hr = key.SetValue(value_name, static_cast<const uint8*>(value),
+ hr = key.SetValue(value_name, static_cast<const uint8_t*>(value),
byte_count);
break;
case REG_MULTI_SZ:
- hr = key.SetValue(value_name, static_cast<const uint8*>(value),
+ hr = key.SetValue(value_name, static_cast<const uint8_t*>(value),
byte_count, type);
break;
default:
@@ -461,7 +461,7 @@
std::vector<std::wstring>*>(value));
break;
case REG_BINARY:
- hr = key.GetValue(value_name, reinterpret_cast<uint8**>(value),
+ hr = key.GetValue(value_name, reinterpret_cast<uint8_t**>(value),
byte_count);
break;
default:
@@ -482,7 +482,7 @@
// GET helper
HRESULT RegKey::GetValueHelper(const wchar_t* value_name,
DWORD* type,
- uint8** value,
+ uint8_t** value,
DWORD* byte_count) const {
ASSERT(byte_count != NULL);
ASSERT(value != NULL);
@@ -608,7 +608,7 @@
}
// convert REG_MULTI_SZ bytes to string array
-HRESULT RegKey::MultiSZBytesToStringArray(const uint8* buffer,
+HRESULT RegKey::MultiSZBytesToStringArray(const uint8_t* buffer,
DWORD byte_count,
std::vector<std::wstring>* value) {
ASSERT(buffer != NULL);
@@ -640,7 +640,7 @@
DWORD byte_count = 0;
DWORD type = 0;
- uint8* buffer = 0;
+ uint8_t* buffer = 0;
// first get the size of the buffer
HRESULT hr = GetValueHelper(value_name, &type, &buffer, &byte_count);
@@ -655,7 +655,7 @@
// Binary data Get
HRESULT RegKey::GetValue(const wchar_t* value_name,
- uint8** value,
+ uint8_t** value,
DWORD* byte_count) const {
ASSERT(byte_count != NULL);
ASSERT(value != NULL);
@@ -668,9 +668,9 @@
// Raw data get
HRESULT RegKey::GetValue(const wchar_t* value_name,
- uint8** value,
+ uint8_t** value,
DWORD* byte_count,
- DWORD*type) const {
+ DWORD* type) const {
ASSERT(type != NULL);
ASSERT(byte_count != NULL);
ASSERT(value != NULL);
@@ -682,9 +682,9 @@
HRESULT RegKey::SetValue(const wchar_t* value_name, DWORD value) const {
ASSERT(h_key_ != NULL);
- LONG res = ::RegSetValueEx(h_key_, value_name, NULL, REG_DWORD,
- reinterpret_cast<const uint8*>(&value),
- sizeof(DWORD));
+ LONG res =
+ ::RegSetValueEx(h_key_, value_name, NULL, REG_DWORD,
+ reinterpret_cast<const uint8_t*>(&value), sizeof(DWORD));
return HRESULT_FROM_WIN32(res);
}
@@ -693,7 +693,7 @@
ASSERT(h_key_ != NULL);
LONG res = ::RegSetValueEx(h_key_, value_name, NULL, REG_QWORD,
- reinterpret_cast<const uint8*>(&value),
+ reinterpret_cast<const uint8_t*>(&value),
sizeof(DWORD64));
return HRESULT_FROM_WIN32(res);
}
@@ -705,14 +705,14 @@
ASSERT(h_key_ != NULL);
LONG res = ::RegSetValueEx(h_key_, value_name, NULL, REG_SZ,
- reinterpret_cast<const uint8*>(value),
+ reinterpret_cast<const uint8_t*>(value),
(lstrlen(value) + 1) * sizeof(wchar_t));
return HRESULT_FROM_WIN32(res);
}
// Binary data set
HRESULT RegKey::SetValue(const wchar_t* value_name,
- const uint8* value,
+ const uint8_t* value,
DWORD byte_count) const {
ASSERT(h_key_ != NULL);
@@ -728,7 +728,7 @@
// Raw data set
HRESULT RegKey::SetValue(const wchar_t* value_name,
- const uint8* value,
+ const uint8_t* value,
DWORD byte_count,
DWORD type) const {
ASSERT(value != NULL);
@@ -964,7 +964,7 @@
}
// get the number of values for this key
-uint32 RegKey::GetValueCount() {
+uint32_t RegKey::GetValueCount() {
DWORD num_values = 0;
if (ERROR_SUCCESS != ::RegQueryInfoKey(
@@ -1007,7 +1007,7 @@
return HRESULT_FROM_WIN32(res);
}
-uint32 RegKey::GetSubkeyCount() {
+uint32_t RegKey::GetSubkeyCount() {
// number of values for key
DWORD num_subkeys = 0;
diff --git a/webrtc/base/win32regkey.h b/webrtc/base/win32regkey.h
index 5508ea7..d5c51b9 100644
--- a/webrtc/base/win32regkey.h
+++ b/webrtc/base/win32regkey.h
@@ -64,7 +64,7 @@
bool HasValue(const wchar_t* value_name) const;
// get the number of values for this key
- uint32 GetValueCount();
+ uint32_t GetValueCount();
// Called to get the value name for the given value name index
// Use GetValueCount() to get the total value_name count for this key
@@ -80,7 +80,7 @@
bool HasSubkey(const wchar_t* key_name) const;
// get the number of subkeys for this key
- uint32 GetSubkeyCount();
+ uint32_t GetSubkeyCount();
// Called to get the key name for the given key index
// Use GetSubkeyCount() to get the total count for this key
@@ -92,10 +92,10 @@
// SETTERS
- // set an int32 value - use when reading multiple values from a key
+ // set an int32_t value - use when reading multiple values from a key
HRESULT SetValue(const wchar_t* value_name, DWORD value) const;
- // set an int64 value
+ // set an int64_t value
HRESULT SetValue(const wchar_t* value_name, DWORD64 value) const;
// set a string value
@@ -103,21 +103,21 @@
// set binary data
HRESULT SetValue(const wchar_t* value_name,
- const uint8* value,
+ const uint8_t* value,
DWORD byte_count) const;
// set raw data, including type
HRESULT SetValue(const wchar_t* value_name,
- const uint8* value,
+ const uint8_t* value,
DWORD byte_count,
DWORD type) const;
// GETTERS
- // get an int32 value
+ // get an int32_t value
HRESULT GetValue(const wchar_t* value_name, DWORD* value) const;
- // get an int64 value
+ // get an int64_t value
HRESULT GetValue(const wchar_t* value_name, DWORD64* value) const;
// get a string value - the caller must free the return buffer
@@ -132,12 +132,12 @@
// get binary data - the caller must free the return buffer
HRESULT GetValue(const wchar_t* value_name,
- uint8** value,
+ uint8_t** value,
DWORD* byte_count) const;
// get raw data, including type - the caller must free the return buffer
HRESULT GetValue(const wchar_t* value_name,
- uint8** value,
+ uint8_t** value,
DWORD* byte_count,
DWORD* type) const;
@@ -154,12 +154,12 @@
// SETTERS
- // STATIC int32 set
+ // STATIC int32_t set
static HRESULT SetValue(const wchar_t* full_key_name,
const wchar_t* value_name,
DWORD value);
- // STATIC int64 set
+ // STATIC int64_t set
static HRESULT SetValue(const wchar_t* full_key_name,
const wchar_t* value_name,
DWORD64 value);
@@ -182,23 +182,23 @@
// STATIC binary data set
static HRESULT SetValue(const wchar_t* full_key_name,
const wchar_t* value_name,
- const uint8* value,
+ const uint8_t* value,
DWORD byte_count);
// STATIC multi-string set
static HRESULT SetValueMultiSZ(const wchar_t* full_key_name,
const TCHAR* value_name,
- const uint8* value,
+ const uint8_t* value,
DWORD byte_count);
// GETTERS
- // STATIC int32 get
+ // STATIC int32_t get
static HRESULT GetValue(const wchar_t* full_key_name,
const wchar_t* value_name,
DWORD* value);
- // STATIC int64 get
+ // STATIC int64_t get
//
// Note: if you are using time64 you should
// likely use GetLimitedTimeValue (util.h) instead of this method.
@@ -233,7 +233,7 @@
// STATIC get binary data - the caller must free the return buffer
static HRESULT GetValue(const wchar_t* full_key_name,
const wchar_t* value_name,
- uint8** value,
+ uint8_t** value,
DWORD* byte_count);
// Get type of a registry value
@@ -297,7 +297,8 @@
// helper function to get any value from the registry
// used when the size of the data is unknown
HRESULT GetValueHelper(const wchar_t* value_name,
- DWORD* type, uint8** value,
+ DWORD* type,
+ uint8_t** value,
DWORD* byte_count) const;
// helper function to get the parent key name and the subkey from a string
@@ -320,7 +321,7 @@
DWORD* byte_count = NULL);
// convert REG_MULTI_SZ bytes to string array
- static HRESULT MultiSZBytesToStringArray(const uint8* buffer,
+ static HRESULT MultiSZBytesToStringArray(const uint8_t* buffer,
DWORD byte_count,
std::vector<std::wstring>* value);
diff --git a/webrtc/base/win32regkey_unittest.cc b/webrtc/base/win32regkey_unittest.cc
index d263051..389c3a2 100644
--- a/webrtc/base/win32regkey_unittest.cc
+++ b/webrtc/base/win32regkey_unittest.cc
@@ -150,18 +150,18 @@
std::vector<std::wstring> result;
EXPECT_SUCCEEDED(RegKey::MultiSZBytesToStringArray(
- reinterpret_cast<const uint8*>(kMultiSZ), sizeof(kMultiSZ), &result));
+ reinterpret_cast<const uint8_t*>(kMultiSZ), sizeof(kMultiSZ), &result));
EXPECT_EQ(result.size(), 3);
EXPECT_STREQ(result[0].c_str(), L"abc");
EXPECT_STREQ(result[1].c_str(), L"def");
EXPECT_STREQ(result[2].c_str(), L"P12345");
EXPECT_SUCCEEDED(RegKey::MultiSZBytesToStringArray(
- reinterpret_cast<const uint8*>(kEmptyMultiSZ),
- sizeof(kEmptyMultiSZ), &result));
+ reinterpret_cast<const uint8_t*>(kEmptyMultiSZ), sizeof(kEmptyMultiSZ),
+ &result));
EXPECT_EQ(result.size(), 0);
EXPECT_FALSE(SUCCEEDED(RegKey::MultiSZBytesToStringArray(
- reinterpret_cast<const uint8*>(kInvalidMultiSZ),
+ reinterpret_cast<const uint8_t*>(kInvalidMultiSZ),
sizeof(kInvalidMultiSZ), &result)));
}
@@ -173,7 +173,7 @@
DWORD int_val = 0;
DWORD64 int64_val = 0;
wchar_t* str_val = NULL;
- uint8* binary_val = NULL;
+ uint8_t* binary_val = NULL;
DWORD uint8_count = 0;
// Just in case...
@@ -265,7 +265,8 @@
// set a binary value
EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary,
- reinterpret_cast<const uint8*>(kBinaryVal), sizeof(kBinaryVal) - 1));
+ reinterpret_cast<const uint8_t*>(kBinaryVal),
+ sizeof(kBinaryVal) - 1));
// check that the value exists
EXPECT_TRUE(r_key.HasValue(kValNameBinary));
@@ -277,7 +278,8 @@
// set it again
EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary,
- reinterpret_cast<const uint8*>(kBinaryVal2), sizeof(kBinaryVal) - 1));
+ reinterpret_cast<const uint8_t*>(kBinaryVal2),
+ sizeof(kBinaryVal) - 1));
// read it again
EXPECT_SUCCEEDED(r_key.GetValue(kValNameBinary, &binary_val, &uint8_count));
@@ -303,10 +305,11 @@
// set a binary value
EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary,
- reinterpret_cast<const uint8*>(kBinaryVal), sizeof(kBinaryVal) - 1));
+ reinterpret_cast<const uint8_t*>(kBinaryVal),
+ sizeof(kBinaryVal) - 1));
// get the value count
- uint32 value_count = r_key.GetValueCount();
+ uint32_t value_count = r_key.GetValueCount();
EXPECT_EQ(value_count, 4);
// check the value names
@@ -332,7 +335,7 @@
// check that there are no more values
EXPECT_FAILED(r_key.GetValueNameAt(4, &value_name, &type));
- uint32 subkey_count = r_key.GetSubkeyCount();
+ uint32_t subkey_count = r_key.GetSubkeyCount();
EXPECT_EQ(subkey_count, 0);
// now create a subkey and make sure we can get the name
@@ -366,7 +369,7 @@
double double_val = 0;
wchar_t* str_val = NULL;
std::wstring wstr_val;
- uint8* binary_val = NULL;
+ uint8_t* binary_val = NULL;
DWORD uint8_count = 0;
// Just in case...
@@ -377,7 +380,7 @@
EXPECT_EQ(RegKey::GetValue(kFullRkey1, kValNameInt, &int_val),
HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND));
- // set int32
+ // set int32_t
EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameInt, kIntVal));
// check that the value exists
@@ -397,7 +400,7 @@
// check that the value is gone
EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameInt));
- // set int64
+ // set int64_t
EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameInt64, kIntVal64));
// check that the value exists
@@ -473,8 +476,9 @@
EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameStr));
// set binary
- EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameBinary,
- reinterpret_cast<const uint8*>(kBinaryVal), sizeof(kBinaryVal)-1));
+ EXPECT_SUCCEEDED(RegKey::SetValue(
+ kFullRkey1, kValNameBinary, reinterpret_cast<const uint8_t*>(kBinaryVal),
+ sizeof(kBinaryVal) - 1));
// check that the value exists
EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameBinary));
@@ -492,8 +496,9 @@
EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameBinary));
// special case - set a binary value with length 0
- EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameBinary,
- reinterpret_cast<const uint8*>(kBinaryVal), 0));
+ EXPECT_SUCCEEDED(
+ RegKey::SetValue(kFullRkey1, kValNameBinary,
+ reinterpret_cast<const uint8_t*>(kBinaryVal), 0));
// check that the value exists
EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameBinary));
@@ -532,20 +537,24 @@
// test read/write REG_MULTI_SZ value
std::vector<std::wstring> result;
- EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr,
- reinterpret_cast<const uint8*>(kMultiSZ), sizeof(kMultiSZ)));
+ EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(
+ kFullRkey1, kValNameMultiStr, reinterpret_cast<const uint8_t*>(kMultiSZ),
+ sizeof(kMultiSZ)));
EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result));
EXPECT_EQ(result.size(), 3);
EXPECT_STREQ(result[0].c_str(), L"abc");
EXPECT_STREQ(result[1].c_str(), L"def");
EXPECT_STREQ(result[2].c_str(), L"P12345");
- EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr,
- reinterpret_cast<const uint8*>(kEmptyMultiSZ), sizeof(kEmptyMultiSZ)));
+ EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(
+ kFullRkey1, kValNameMultiStr,
+ reinterpret_cast<const uint8_t*>(kEmptyMultiSZ), sizeof(kEmptyMultiSZ)));
EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result));
EXPECT_EQ(result.size(), 0);
// writing REG_MULTI_SZ value will automatically add ending null characters
- EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr,
- reinterpret_cast<const uint8*>(kInvalidMultiSZ), sizeof(kInvalidMultiSZ)));
+ EXPECT_SUCCEEDED(
+ RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr,
+ reinterpret_cast<const uint8_t*>(kInvalidMultiSZ),
+ sizeof(kInvalidMultiSZ)));
EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result));
EXPECT_EQ(result.size(), 1);
EXPECT_STREQ(result[0].c_str(), L"678");
diff --git a/webrtc/base/win32socketserver.cc b/webrtc/base/win32socketserver.cc
index 2adb0d3..743f8c0 100644
--- a/webrtc/base/win32socketserver.cc
+++ b/webrtc/base/win32socketserver.cc
@@ -28,26 +28,26 @@
// TODO: Move this to a common place where PhysicalSocketServer can
// share it.
// Standard MTUs
-static const uint16 PACKET_MAXIMUMS[] = {
- 65535, // Theoretical maximum, Hyperchannel
- 32000, // Nothing
- 17914, // 16Mb IBM Token Ring
- 8166, // IEEE 802.4
- // 4464 // IEEE 802.5 (4Mb max)
- 4352, // FDDI
- // 2048, // Wideband Network
- 2002, // IEEE 802.5 (4Mb recommended)
- // 1536, // Expermental Ethernet Networks
- // 1500, // Ethernet, Point-to-Point (default)
- 1492, // IEEE 802.3
- 1006, // SLIP, ARPANET
- // 576, // X.25 Networks
- // 544, // DEC IP Portal
- // 512, // NETBIOS
- 508, // IEEE 802/Source-Rt Bridge, ARCNET
- 296, // Point-to-Point (low delay)
- 68, // Official minimum
- 0, // End of list marker
+static const uint16_t PACKET_MAXIMUMS[] = {
+ 65535, // Theoretical maximum, Hyperchannel
+ 32000, // Nothing
+ 17914, // 16Mb IBM Token Ring
+ 8166, // IEEE 802.4
+ // 4464 // IEEE 802.5 (4Mb max)
+ 4352, // FDDI
+ // 2048, // Wideband Network
+ 2002, // IEEE 802.5 (4Mb recommended)
+ // 1536, // Expermental Ethernet Networks
+ // 1500, // Ethernet, Point-to-Point (default)
+ 1492, // IEEE 802.3
+ 1006, // SLIP, ARPANET
+ // 576, // X.25 Networks
+ // 544, // DEC IP Portal
+ // 512, // NETBIOS
+ 508, // IEEE 802/Source-Rt Bridge, ARCNET
+ 296, // Point-to-Point (low delay)
+ 68, // Official minimum
+ 0, // End of list marker
};
static const int IP_HEADER_SIZE = 20u;
@@ -143,7 +143,7 @@
struct Win32Socket::DnsLookup {
HANDLE handle;
- uint16 port;
+ uint16_t port;
char buffer[MAXGETHOSTSTRUCT];
};
@@ -512,7 +512,7 @@
return err;
}
-int Win32Socket::EstimateMTU(uint16* mtu) {
+int Win32Socket::EstimateMTU(uint16_t* mtu) {
SocketAddress addr = GetRemoteAddress();
if (addr.IsAny()) {
error_ = ENOTCONN;
@@ -526,7 +526,7 @@
}
for (int level = 0; PACKET_MAXIMUMS[level + 1] > 0; ++level) {
- int32 size = PACKET_MAXIMUMS[level] - IP_HEADER_SIZE - ICMP_HEADER_SIZE;
+ int32_t size = PACKET_MAXIMUMS[level] - IP_HEADER_SIZE - ICMP_HEADER_SIZE;
WinPing::PingResult result = ping.Ping(addr.ipaddr(), size,
ICMP_PING_TIMEOUT_MILLIS, 1, false);
if (result == WinPing::PING_FAIL) {
@@ -627,7 +627,7 @@
if (error != ERROR_SUCCESS) {
ReportWSAError("WSAAsync:connect notify", error, addr_);
#ifdef _DEBUG
- int32 duration = TimeSince(connect_time_);
+ int32_t duration = TimeSince(connect_time_);
LOG(LS_INFO) << "WSAAsync:connect error (" << duration
<< " ms), faking close";
#endif
@@ -640,7 +640,7 @@
SignalCloseEvent(this, error);
} else {
#ifdef _DEBUG
- int32 duration = TimeSince(connect_time_);
+ int32_t duration = TimeSince(connect_time_);
LOG(LS_INFO) << "WSAAsync:connect (" << duration << " ms)";
#endif
state_ = CS_CONNECTED;
@@ -679,10 +679,10 @@
if (!dns_ || dns_->handle != task)
return;
- uint32 ip = 0;
+ uint32_t ip = 0;
if (error == 0) {
hostent* pHost = reinterpret_cast<hostent*>(dns_->buffer);
- uint32 net_ip = *reinterpret_cast<uint32*>(pHost->h_addr_list[0]);
+ uint32_t net_ip = *reinterpret_cast<uint32_t*>(pHost->h_addr_list[0]);
ip = NetworkToHost32(net_ip);
}
@@ -762,7 +762,7 @@
if (process_io) {
// Spin the Win32 message pump at least once, and as long as requested.
// This is the Thread::ProcessMessages case.
- uint32 start = Time();
+ uint32_t start = Time();
do {
MSG msg;
SetTimer(wnd_.handle(), 0, cms, NULL);
diff --git a/webrtc/base/win32socketserver.h b/webrtc/base/win32socketserver.h
index a03f6c0..b468cfd 100644
--- a/webrtc/base/win32socketserver.h
+++ b/webrtc/base/win32socketserver.h
@@ -52,7 +52,7 @@
virtual int GetError() const;
virtual void SetError(int error);
virtual ConnState GetState() const;
- virtual int EstimateMTU(uint16* mtu);
+ virtual int EstimateMTU(uint16_t* mtu);
virtual int GetOption(Option opt, int* value);
virtual int SetOption(Option opt, int value);
@@ -72,7 +72,7 @@
int error_;
ConnState state_;
SocketAddress addr_; // address that we connected to (see DoConnect)
- uint32 connect_time_;
+ uint32_t connect_time_;
bool closing_;
int close_error_;
diff --git a/webrtc/base/win32socketserver_unittest.cc b/webrtc/base/win32socketserver_unittest.cc
index 1d3ef2e..daf9e70 100644
--- a/webrtc/base/win32socketserver_unittest.cc
+++ b/webrtc/base/win32socketserver_unittest.cc
@@ -17,7 +17,7 @@
// Test that Win32SocketServer::Wait works as expected.
TEST(Win32SocketServerTest, TestWait) {
Win32SocketServer server(NULL);
- uint32 start = Time();
+ uint32_t start = Time();
server.Wait(1000, true);
EXPECT_GE(TimeSince(start), 1000);
}
diff --git a/webrtc/base/window.h b/webrtc/base/window.h
index 9f4381a..b1f1724 100644
--- a/webrtc/base/window.h
+++ b/webrtc/base/window.h
@@ -40,7 +40,7 @@
typedef unsigned int WindowT;
#endif
- static WindowId Cast(uint64 id) {
+ static WindowId Cast(uint64_t id) {
#if defined(WEBRTC_WIN)
return WindowId(reinterpret_cast<WindowId::WindowT>(id));
#else
@@ -48,11 +48,11 @@
#endif
}
- static uint64 Format(const WindowT& id) {
+ static uint64_t Format(const WindowT& id) {
#if defined(WEBRTC_WIN)
- return static_cast<uint64>(reinterpret_cast<uintptr_t>(id));
+ return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(id));
#else
- return static_cast<uint64>(id);
+ return static_cast<uint64_t>(id);
#endif
}
diff --git a/webrtc/base/winping.cc b/webrtc/base/winping.cc
index fa8dfc2..be436c3 100644
--- a/webrtc/base/winping.cc
+++ b/webrtc/base/winping.cc
@@ -126,11 +126,11 @@
const char * const ICMP6_CREATE_FUNC = "Icmp6CreateFile";
const char * const ICMP6_SEND_FUNC = "Icmp6SendEcho2";
-inline uint32 ReplySize(uint32 data_size, int family) {
+inline uint32_t ReplySize(uint32_t data_size, int family) {
if (family == AF_INET) {
// A ping error message is 8 bytes long, so make sure we allow for at least
// 8 bytes of reply data.
- return sizeof(ICMP_ECHO_REPLY) + std::max<uint32>(8, data_size);
+ return sizeof(ICMP_ECHO_REPLY) + std::max<uint32_t>(8, data_size);
} else if (family == AF_INET6) {
// Per MSDN, Send6IcmpEcho2 needs at least one ICMPV6_ECHO_REPLY,
// 8 bytes for ICMP header, _and_ an IO_BLOCK_STATUS (2 pointers),
@@ -208,10 +208,11 @@
delete[] reply_;
}
-WinPing::PingResult WinPing::Ping(
- IPAddress ip, uint32 data_size, uint32 timeout, uint8 ttl,
- bool allow_fragments) {
-
+WinPing::PingResult WinPing::Ping(IPAddress ip,
+ uint32_t data_size,
+ uint32_t timeout,
+ uint8_t ttl,
+ bool allow_fragments) {
if (data_size == 0 || timeout == 0 || ttl == 0) {
LOG(LERROR) << "IcmpSendEcho: data_size/timeout/ttl is 0.";
return PING_INVALID_PARAMS;
@@ -225,7 +226,7 @@
ipopt.Flags |= IP_FLAG_DF;
ipopt.Ttl = ttl;
- uint32 reply_size = ReplySize(data_size, ip.family());
+ uint32_t reply_size = ReplySize(data_size, ip.family());
if (data_size > dlen_) {
delete [] data_;
@@ -241,19 +242,16 @@
}
DWORD result = 0;
if (ip.family() == AF_INET) {
- result = send_(hping_, ip.ipv4_address().S_un.S_addr,
- data_, uint16(data_size), &ipopt,
- reply_, reply_size, timeout);
+ result = send_(hping_, ip.ipv4_address().S_un.S_addr, data_,
+ uint16_t(data_size), &ipopt, reply_, reply_size, timeout);
} else if (ip.family() == AF_INET6) {
sockaddr_in6 src = {0};
sockaddr_in6 dst = {0};
src.sin6_family = AF_INET6;
dst.sin6_family = AF_INET6;
dst.sin6_addr = ip.ipv6_address();
- result = send6_(hping6_, NULL, NULL, NULL,
- &src, &dst,
- data_, int16(data_size), &ipopt,
- reply_, reply_size, timeout);
+ result = send6_(hping6_, NULL, NULL, NULL, &src, &dst, data_,
+ int16_t(data_size), &ipopt, reply_, reply_size, timeout);
}
if (result == 0) {
DWORD error = GetLastError();
diff --git a/webrtc/base/winping.h b/webrtc/base/winping.h
index 75f82b7..ddaefc5 100644
--- a/webrtc/base/winping.h
+++ b/webrtc/base/winping.h
@@ -76,9 +76,11 @@
// Attempts to send a ping with the given parameters.
enum PingResult { PING_FAIL, PING_INVALID_PARAMS,
PING_TOO_LARGE, PING_TIMEOUT, PING_SUCCESS };
- PingResult Ping(
- IPAddress ip, uint32 data_size, uint32 timeout_millis, uint8 ttl,
- bool allow_fragments);
+ PingResult Ping(IPAddress ip,
+ uint32_t data_size,
+ uint32_t timeout_millis,
+ uint8_t ttl,
+ bool allow_fragments);
private:
HMODULE dll_;
@@ -90,9 +92,9 @@
PIcmp6CreateFile create6_;
PIcmp6SendEcho2 send6_;
char* data_;
- uint32 dlen_;
+ uint32_t dlen_;
char* reply_;
- uint32 rlen_;
+ uint32_t rlen_;
bool valid_;
};
diff --git a/webrtc/base/x11windowpicker.cc b/webrtc/base/x11windowpicker.cc
index f7c7911..21f71c6 100644
--- a/webrtc/base/x11windowpicker.cc
+++ b/webrtc/base/x11windowpicker.cc
@@ -277,7 +277,7 @@
return true;
}
- uint8* GetWindowIcon(const WindowId& id, int* width, int* height) {
+ uint8_t* GetWindowIcon(const WindowId& id, int* width, int* height) {
if (!Init()) {
return NULL;
}
@@ -297,14 +297,14 @@
LOG(LS_ERROR) << "Failed to get size of the icon.";
return NULL;
}
- // Get the icon data, the format is one uint32 each for width and height,
+ // Get the icon data, the format is one uint32_t each for width and height,
// followed by the actual pixel data.
if (size >= 2 &&
XGetWindowProperty(
display_, id.id(), net_wm_icon_, 0, size, False, XA_CARDINAL,
&ret_type, &format, &length, &bytes_after, &data) == Success &&
data) {
- uint32* data_ptr = reinterpret_cast<uint32*>(data);
+ uint32_t* data_ptr = reinterpret_cast<uint32_t*>(data);
int w, h;
w = data_ptr[0];
h = data_ptr[1];
@@ -313,8 +313,7 @@
LOG(LS_ERROR) << "Not a vaild icon.";
return NULL;
}
- uint8* rgba =
- ArgbToRgba(&data_ptr[2], 0, 0, w, h, w, h, true);
+ uint8_t* rgba = ArgbToRgba(&data_ptr[2], 0, 0, w, h, w, h, true);
XFree(data);
*width = w;
*height = h;
@@ -325,7 +324,7 @@
}
}
- uint8* GetWindowThumbnail(const WindowId& id, int width, int height) {
+ uint8_t* GetWindowThumbnail(const WindowId& id, int width, int height) {
if (!Init()) {
return NULL;
}
@@ -390,12 +389,8 @@
return NULL;
}
- uint8* data = GetDrawableThumbnail(src_pixmap,
- attr.visual,
- src_width,
- src_height,
- width,
- height);
+ uint8_t* data = GetDrawableThumbnail(src_pixmap, attr.visual, src_width,
+ src_height, width, height);
XFreePixmap(display_, src_pixmap);
return data;
}
@@ -408,7 +403,7 @@
return XScreenCount(display_);
}
- uint8* GetDesktopThumbnail(const DesktopId& id, int width, int height) {
+ uint8_t* GetDesktopThumbnail(const DesktopId& id, int width, int height) {
if (!Init()) {
return NULL;
}
@@ -445,12 +440,12 @@
}
private:
- uint8* GetDrawableThumbnail(Drawable src_drawable,
- Visual* visual,
- int src_width,
- int src_height,
- int dst_width,
- int dst_height) {
+ uint8_t* GetDrawableThumbnail(Drawable src_drawable,
+ Visual* visual,
+ int src_width,
+ int src_height,
+ int dst_width,
+ int dst_height) {
if (!has_render_extension_) {
// Without the Xrender extension we would have to read the full window and
// scale it down in our process. Xrender is over a decade old so we aren't
@@ -561,14 +556,9 @@
dst_width,
dst_height,
AllPlanes, ZPixmap);
- uint8* data = ArgbToRgba(reinterpret_cast<uint32*>(image->data),
- centered_x,
- centered_y,
- scaled_width,
- scaled_height,
- dst_width,
- dst_height,
- false);
+ uint8_t* data = ArgbToRgba(reinterpret_cast<uint32_t*>(image->data),
+ centered_x, centered_y, scaled_width,
+ scaled_height, dst_width, dst_height, false);
XDestroyImage(image);
XRenderFreePicture(display_, dst);
XFreePixmap(display_, dst_pixmap);
@@ -576,17 +566,23 @@
return data;
}
- uint8* ArgbToRgba(uint32* argb_data, int x, int y, int w, int h,
- int stride_x, int stride_y, bool has_alpha) {
- uint8* p;
+ uint8_t* ArgbToRgba(uint32_t* argb_data,
+ int x,
+ int y,
+ int w,
+ int h,
+ int stride_x,
+ int stride_y,
+ bool has_alpha) {
+ uint8_t* p;
int len = stride_x * stride_y * 4;
- uint8* data = new uint8[len];
+ uint8_t* data = new uint8_t[len];
memset(data, 0, len);
p = data + 4 * (y * stride_x + x);
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
- uint32 argb;
- uint32 rgba;
+ uint32_t argb;
+ uint32_t rgba;
argb = argb_data[stride_x * (y + i) + x + j];
rgba = (argb << 8) | (argb >> 24);
*p = rgba >> 24;
@@ -691,7 +687,7 @@
return 0;
}
if (type != None) {
- int64 state = static_cast<int64>(*data);
+ int64_t state = static_cast<int64_t>(*data);
XFree(data);
return state == NormalState ? window : 0;
}
@@ -789,13 +785,14 @@
return enumerator_->MoveToFront(id);
}
-
-uint8* X11WindowPicker::GetWindowIcon(const WindowId& id, int* width,
+uint8_t* X11WindowPicker::GetWindowIcon(const WindowId& id,
+ int* width,
int* height) {
return enumerator_->GetWindowIcon(id, width, height);
}
-uint8* X11WindowPicker::GetWindowThumbnail(const WindowId& id, int width,
+uint8_t* X11WindowPicker::GetWindowThumbnail(const WindowId& id,
+ int width,
int height) {
return enumerator_->GetWindowThumbnail(id, width, height);
}
@@ -804,7 +801,7 @@
return enumerator_->GetNumDesktops();
}
-uint8* X11WindowPicker::GetDesktopThumbnail(const DesktopId& id,
+uint8_t* X11WindowPicker::GetDesktopThumbnail(const DesktopId& id,
int width,
int height) {
return enumerator_->GetDesktopThumbnail(id, width, height);
diff --git a/webrtc/base/x11windowpicker.h b/webrtc/base/x11windowpicker.h
index b340b88..501adf5 100644
--- a/webrtc/base/x11windowpicker.h
+++ b/webrtc/base/x11windowpicker.h
@@ -38,10 +38,10 @@
bool GetDesktopDimensions(const DesktopId& id,
int* width,
int* height) override;
- uint8* GetWindowIcon(const WindowId& id, int* width, int* height);
- uint8* GetWindowThumbnail(const WindowId& id, int width, int height);
+ uint8_t* GetWindowIcon(const WindowId& id, int* width, int* height);
+ uint8_t* GetWindowThumbnail(const WindowId& id, int width, int height);
int GetNumDesktops();
- uint8* GetDesktopThumbnail(const DesktopId& id, int width, int height);
+ uint8_t* GetDesktopThumbnail(const DesktopId& id, int width, int height);
private:
scoped_ptr<XWindowEnumerator> enumerator_;
diff --git a/webrtc/examples/android/media_demo/jni/jni_helpers.h b/webrtc/examples/android/media_demo/jni/jni_helpers.h
index c3f2b5d..3d8ff48 100644
--- a/webrtc/examples/android/media_demo/jni/jni_helpers.h
+++ b/webrtc/examples/android/media_demo/jni/jni_helpers.h
@@ -51,7 +51,7 @@
const char* signature);
// Return a |jlong| that will automatically convert back to |ptr| when assigned
-// to a |uint64|
+// to a |uint64_t|
jlong jlongFromPointer(void* ptr);
// Given a (UTF-16) jstring return a new UTF-8 native string.
diff --git a/webrtc/examples/peerconnection/client/defaults.cc b/webrtc/examples/peerconnection/client/defaults.cc
index b686cd7..3090c15 100644
--- a/webrtc/examples/peerconnection/client/defaults.cc
+++ b/webrtc/examples/peerconnection/client/defaults.cc
@@ -24,7 +24,7 @@
const char kAudioLabel[] = "audio_label";
const char kVideoLabel[] = "video_label";
const char kStreamLabel[] = "stream_label";
-const uint16 kDefaultServerPort = 8888;
+const uint16_t kDefaultServerPort = 8888;
std::string GetEnvVarOrDefault(const char* env_var_name,
const char* default_value) {
diff --git a/webrtc/examples/peerconnection/client/defaults.h b/webrtc/examples/peerconnection/client/defaults.h
index ab8276b..7b50397 100644
--- a/webrtc/examples/peerconnection/client/defaults.h
+++ b/webrtc/examples/peerconnection/client/defaults.h
@@ -19,7 +19,7 @@
extern const char kAudioLabel[];
extern const char kVideoLabel[];
extern const char kStreamLabel[];
-extern const uint16 kDefaultServerPort;
+extern const uint16_t kDefaultServerPort;
std::string GetEnvVarOrDefault(const char* env_var_name,
const char* default_value);
diff --git a/webrtc/examples/peerconnection/client/flagdefs.h b/webrtc/examples/peerconnection/client/flagdefs.h
index 00e134d..0cffffb 100644
--- a/webrtc/examples/peerconnection/client/flagdefs.h
+++ b/webrtc/examples/peerconnection/client/flagdefs.h
@@ -14,7 +14,7 @@
#include "webrtc/base/flags.h"
-extern const uint16 kDefaultServerPort; // From defaults.[h|cc]
+extern const uint16_t kDefaultServerPort; // From defaults.[h|cc]
// Define flags for the peerconnect_client testing tool, in a separate
// header file so that they can be shared across the different main.cc's
diff --git a/webrtc/examples/peerconnection/client/linux/main_wnd.cc b/webrtc/examples/peerconnection/client/linux/main_wnd.cc
index 02b6e32..254fb94 100644
--- a/webrtc/examples/peerconnection/client/linux/main_wnd.cc
+++ b/webrtc/examples/peerconnection/client/linux/main_wnd.cc
@@ -394,20 +394,20 @@
if (!draw_buffer_.get()) {
draw_buffer_size_ = (width * height * 4) * 4;
- draw_buffer_.reset(new uint8[draw_buffer_size_]);
+ draw_buffer_.reset(new uint8_t[draw_buffer_size_]);
gtk_widget_set_size_request(draw_area_, width * 2, height * 2);
}
- const uint32* image = reinterpret_cast<const uint32*>(
- remote_renderer->image());
- uint32* scaled = reinterpret_cast<uint32*>(draw_buffer_.get());
+ const uint32_t* image =
+ reinterpret_cast<const uint32_t*>(remote_renderer->image());
+ uint32_t* scaled = reinterpret_cast<uint32_t*>(draw_buffer_.get());
for (int r = 0; r < height; ++r) {
for (int c = 0; c < width; ++c) {
int x = c * 2;
scaled[x] = scaled[x + 1] = image[c];
}
- uint32* prev_line = scaled;
+ uint32_t* prev_line = scaled;
scaled += width * 2;
memcpy(scaled, prev_line, (width * 2) * 4);
@@ -417,8 +417,8 @@
VideoRenderer* local_renderer = local_renderer_.get();
if (local_renderer && local_renderer->image()) {
- image = reinterpret_cast<const uint32*>(local_renderer->image());
- scaled = reinterpret_cast<uint32*>(draw_buffer_.get());
+ image = reinterpret_cast<const uint32_t*>(local_renderer->image());
+ scaled = reinterpret_cast<uint32_t*>(draw_buffer_.get());
// Position the local preview on the right side.
scaled += (width * 2) - (local_renderer->width() / 2);
// right margin...
@@ -474,7 +474,7 @@
width_ = width;
height_ = height;
- image_.reset(new uint8[width * height * 4]);
+ image_.reset(new uint8_t[width * height * 4]);
gdk_threads_leave();
}
@@ -495,8 +495,8 @@
width_ * 4);
// Convert the B,G,R,A frame to R,G,B,A, which is accepted by GTK.
// The 'A' is just padding for GTK, so we can use it as temp.
- uint8* pix = image_.get();
- uint8* end = image_.get() + size;
+ uint8_t* pix = image_.get();
+ uint8_t* end = image_.get() + size;
while (pix < end) {
pix[3] = pix[0]; // Save B to A.
pix[0] = pix[2]; // Set Red.
diff --git a/webrtc/examples/peerconnection/client/linux/main_wnd.h b/webrtc/examples/peerconnection/client/linux/main_wnd.h
index cfb2376..1a91082 100644
--- a/webrtc/examples/peerconnection/client/linux/main_wnd.h
+++ b/webrtc/examples/peerconnection/client/linux/main_wnd.h
@@ -79,9 +79,7 @@
virtual void SetSize(int width, int height);
virtual void RenderFrame(const cricket::VideoFrame* frame);
- const uint8* image() const {
- return image_.get();
- }
+ const uint8_t* image() const { return image_.get(); }
int width() const {
return width_;
@@ -92,7 +90,7 @@
}
protected:
- rtc::scoped_ptr<uint8[]> image_;
+ rtc::scoped_ptr<uint8_t[]> image_;
int width_;
int height_;
GtkMainWnd* main_wnd_;
@@ -113,7 +111,7 @@
bool autocall_;
rtc::scoped_ptr<VideoRenderer> local_renderer_;
rtc::scoped_ptr<VideoRenderer> remote_renderer_;
- rtc::scoped_ptr<uint8> draw_buffer_;
+ rtc::scoped_ptr<uint8_t[]> draw_buffer_;
int draw_buffer_size_;
};
diff --git a/webrtc/examples/peerconnection/client/main_wnd.cc b/webrtc/examples/peerconnection/client/main_wnd.cc
index fa356ff..30b12a8 100644
--- a/webrtc/examples/peerconnection/client/main_wnd.cc
+++ b/webrtc/examples/peerconnection/client/main_wnd.cc
@@ -234,7 +234,7 @@
int height = abs(bmi.bmiHeader.biHeight);
int width = bmi.bmiHeader.biWidth;
- const uint8* image = remote_renderer->image();
+ const uint8_t* image = remote_renderer->image();
if (image != NULL) {
HDC dc_mem = ::CreateCompatibleDC(ps.hdc);
::SetStretchBltMode(dc_mem, HALFTONE);
@@ -594,7 +594,7 @@
bmi_.bmiHeader.biHeight = -height;
bmi_.bmiHeader.biSizeImage = width * height *
(bmi_.bmiHeader.biBitCount >> 3);
- image_.reset(new uint8[bmi_.bmiHeader.biSizeImage]);
+ image_.reset(new uint8_t[bmi_.bmiHeader.biSizeImage]);
}
void MainWnd::VideoRenderer::RenderFrame(
diff --git a/webrtc/examples/peerconnection/client/main_wnd.h b/webrtc/examples/peerconnection/client/main_wnd.h
index c11e94d..9f61a56 100644
--- a/webrtc/examples/peerconnection/client/main_wnd.h
+++ b/webrtc/examples/peerconnection/client/main_wnd.h
@@ -120,7 +120,7 @@
virtual void RenderFrame(const cricket::VideoFrame* frame);
const BITMAPINFO& bmi() const { return bmi_; }
- const uint8* image() const { return image_.get(); }
+ const uint8_t* image() const { return image_.get(); }
protected:
enum {
@@ -130,7 +130,7 @@
HWND wnd_;
BITMAPINFO bmi_;
- rtc::scoped_ptr<uint8[]> image_;
+ rtc::scoped_ptr<uint8_t[]> image_;
CRITICAL_SECTION buffer_lock_;
rtc::scoped_refptr<webrtc::VideoTrackInterface> rendered_track_;
};
diff --git a/webrtc/libjingle/xmpp/pingtask.cc b/webrtc/libjingle/xmpp/pingtask.cc
index d44a6d1..479dc23 100644
--- a/webrtc/libjingle/xmpp/pingtask.cc
+++ b/webrtc/libjingle/xmpp/pingtask.cc
@@ -18,8 +18,8 @@
PingTask::PingTask(buzz::XmppTaskParentInterface* parent,
rtc::MessageQueue* message_queue,
- uint32 ping_period_millis,
- uint32 ping_timeout_millis)
+ uint32_t ping_period_millis,
+ uint32_t ping_timeout_millis)
: buzz::XmppTask(parent, buzz::XmppEngine::HL_SINGLE),
message_queue_(message_queue),
ping_period_millis_(ping_period_millis),
@@ -56,7 +56,7 @@
ping_response_deadline_ = 0;
}
- uint32 now = rtc::Time();
+ uint32_t now = rtc::Time();
// If the ping timed out, signal.
if (ping_response_deadline_ != 0 && now >= ping_response_deadline_) {
diff --git a/webrtc/libjingle/xmpp/pingtask.h b/webrtc/libjingle/xmpp/pingtask.h
index 9ea905b..22fd94d 100644
--- a/webrtc/libjingle/xmpp/pingtask.h
+++ b/webrtc/libjingle/xmpp/pingtask.h
@@ -28,8 +28,9 @@
class PingTask : public buzz::XmppTask, private rtc::MessageHandler {
public:
PingTask(buzz::XmppTaskParentInterface* parent,
- rtc::MessageQueue* message_queue, uint32 ping_period_millis,
- uint32 ping_timeout_millis);
+ rtc::MessageQueue* message_queue,
+ uint32_t ping_period_millis,
+ uint32_t ping_timeout_millis);
virtual bool HandleStanza(const buzz::XmlElement* stanza);
virtual int ProcessStart();
@@ -43,10 +44,10 @@
virtual void OnMessage(rtc::Message* msg);
rtc::MessageQueue* message_queue_;
- uint32 ping_period_millis_;
- uint32 ping_timeout_millis_;
- uint32 next_ping_time_;
- uint32 ping_response_deadline_; // 0 if the response has been received
+ uint32_t ping_period_millis_;
+ uint32_t ping_timeout_millis_;
+ uint32_t next_ping_time_;
+ uint32_t ping_response_deadline_; // 0 if the response has been received
};
} // namespace buzz
diff --git a/webrtc/libjingle/xmpp/pingtask_unittest.cc b/webrtc/libjingle/xmpp/pingtask_unittest.cc
index 08a5770..b9aab6b 100644
--- a/webrtc/libjingle/xmpp/pingtask_unittest.cc
+++ b/webrtc/libjingle/xmpp/pingtask_unittest.cc
@@ -74,7 +74,7 @@
}
TEST_F(PingTaskTest, TestSuccess) {
- uint32 ping_period_millis = 100;
+ uint32_t ping_period_millis = 100;
buzz::PingTask* task = new buzz::PingTask(xmpp_client,
rtc::Thread::Current(),
ping_period_millis, ping_period_millis / 10);
@@ -89,7 +89,7 @@
TEST_F(PingTaskTest, TestTimeout) {
respond_to_pings = false;
- uint32 ping_timeout_millis = 200;
+ uint32_t ping_timeout_millis = 200;
buzz::PingTask* task = new buzz::PingTask(xmpp_client,
rtc::Thread::Current(),
ping_timeout_millis * 10, ping_timeout_millis);
diff --git a/webrtc/libjingle/xmpp/xmpppump.cc b/webrtc/libjingle/xmpp/xmpppump.cc
index 45259b1..a428ffa 100644
--- a/webrtc/libjingle/xmpp/xmpppump.cc
+++ b/webrtc/libjingle/xmpp/xmpppump.cc
@@ -49,8 +49,8 @@
rtc::Thread::Current()->Post(this);
}
-int64 XmppPump::CurrentTime() {
- return (int64)rtc::Time();
+int64_t XmppPump::CurrentTime() {
+ return (int64_t)rtc::Time();
}
void XmppPump::OnMessage(rtc::Message *pmsg) {
diff --git a/webrtc/libjingle/xmpp/xmpppump.h b/webrtc/libjingle/xmpp/xmpppump.h
index 8163298..bd1b562 100644
--- a/webrtc/libjingle/xmpp/xmpppump.h
+++ b/webrtc/libjingle/xmpp/xmpppump.h
@@ -44,7 +44,7 @@
void WakeTasks();
- int64 CurrentTime();
+ int64_t CurrentTime();
void OnMessage(rtc::Message *pmsg);
diff --git a/webrtc/libjingle/xmpp/xmppthread.cc b/webrtc/libjingle/xmpp/xmppthread.cc
index faf2164..f492cdf 100644
--- a/webrtc/libjingle/xmpp/xmppthread.cc
+++ b/webrtc/libjingle/xmpp/xmppthread.cc
@@ -16,8 +16,8 @@
namespace buzz {
namespace {
-const uint32 MSG_LOGIN = 1;
-const uint32 MSG_DISCONNECT = 2;
+const uint32_t MSG_LOGIN = 1;
+const uint32_t MSG_DISCONNECT = 2;
struct LoginData: public rtc::MessageData {
LoginData(const buzz::XmppClientSettings& s) : xcs(s) {}
diff --git a/webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.cc b/webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.cc
index dfbb6b7..b78b96d 100644
--- a/webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.cc
+++ b/webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.cc
@@ -90,11 +90,9 @@
return false; \
}
-H264BitstreamParser::PpsState::PpsState() {
-}
+H264BitstreamParser::PpsState::PpsState() {}
-H264BitstreamParser::SpsState::SpsState() {
-}
+H264BitstreamParser::SpsState::SpsState() {}
// These functions are similar to webrtc::H264SpsParser::Parse, and based on the
// same version of the H.264 standard. You can find it here:
@@ -107,7 +105,7 @@
// copy. We'll eventually write this back.
rtc::scoped_ptr<rtc::ByteBuffer> sps_rbsp(
ParseRbsp(sps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize));
- rtc::BitBuffer sps_parser(reinterpret_cast<const uint8*>(sps_rbsp->Data()),
+ rtc::BitBuffer sps_parser(reinterpret_cast<const uint8_t*>(sps_rbsp->Data()),
sps_rbsp->Length());
uint8_t byte_tmp;
@@ -115,7 +113,7 @@
uint32_t bits_tmp;
// profile_idc: u(8).
- uint8 profile_idc;
+ uint8_t profile_idc;
RETURN_FALSE_ON_FAIL(sps_parser.ReadUInt8(&profile_idc));
// constraint_set0_flag through constraint_set5_flag + reserved_zero_2bits
// 1 bit each for the flags + 2 bits = 8 bits = 1 byte.
@@ -131,7 +129,7 @@
profile_idc == 86 || profile_idc == 118 || profile_idc == 128 ||
profile_idc == 138 || profile_idc == 139 || profile_idc == 134) {
// chroma_format_idc: ue(v)
- uint32 chroma_format_idc;
+ uint32_t chroma_format_idc;
RETURN_FALSE_ON_FAIL(sps_parser.ReadExponentialGolomb(&chroma_format_idc));
if (chroma_format_idc == 3) {
// separate_colour_plane_flag: u(1)
@@ -213,7 +211,7 @@
pps_parsed_ = false;
rtc::scoped_ptr<rtc::ByteBuffer> buffer(
ParseRbsp(pps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize));
- rtc::BitBuffer parser(reinterpret_cast<const uint8*>(buffer->Data()),
+ rtc::BitBuffer parser(reinterpret_cast<const uint8_t*>(buffer->Data()),
buffer->Length());
uint32_t bits_tmp;
@@ -322,7 +320,8 @@
rtc::scoped_ptr<rtc::ByteBuffer> slice_rbsp(ParseRbsp(
source + kNaluHeaderAndTypeSize, source_length - kNaluHeaderAndTypeSize));
rtc::BitBuffer slice_reader(
- reinterpret_cast<const uint8*>(slice_rbsp->Data()), slice_rbsp->Length());
+ reinterpret_cast<const uint8_t*>(slice_rbsp->Data()),
+ slice_rbsp->Length());
// Check to see if this is an IDR slice, which has an extra field to parse
// out.
bool is_idr = (source[kNaluHeaderSize] & 0x0F) == kNaluIdr;
@@ -349,7 +348,7 @@
// Represented by log2_max_frame_num_minus4 + 4 bits.
RETURN_FALSE_ON_FAIL(
slice_reader.ReadBits(&bits_tmp, sps_.log2_max_frame_num_minus4 + 4));
- uint32 field_pic_flag = 0;
+ uint32_t field_pic_flag = 0;
if (sps_.frame_mbs_only_flag == 0) {
// field_pic_flag: u(1)
RETURN_FALSE_ON_FAIL(slice_reader.ReadBits(&field_pic_flag, 1));
diff --git a/webrtc/modules/rtp_rtcp/source/h264_sps_parser.cc b/webrtc/modules/rtp_rtcp/source/h264_sps_parser.cc
index d8f9afd..00ab9d4 100644
--- a/webrtc/modules/rtp_rtcp/source/h264_sps_parser.cc
+++ b/webrtc/modules/rtp_rtcp/source/h264_sps_parser.cc
@@ -21,7 +21,7 @@
namespace webrtc {
-H264SpsParser::H264SpsParser(const uint8* sps, size_t byte_length)
+H264SpsParser::H264SpsParser(const uint8_t* sps, size_t byte_length)
: sps_(sps), byte_length_(byte_length), width_(), height_() {
}
@@ -62,22 +62,22 @@
// chroma_format_idc -> affects crop units
// pic_{width,height}_* -> resolution of the frame in macroblocks (16x16).
// frame_crop_*_offset -> crop information
- rtc::BitBuffer parser(reinterpret_cast<const uint8*>(rbsp_buffer.Data()),
+ rtc::BitBuffer parser(reinterpret_cast<const uint8_t*>(rbsp_buffer.Data()),
rbsp_buffer.Length());
// The golomb values we have to read, not just consume.
- uint32 golomb_ignored;
+ uint32_t golomb_ignored;
// separate_colour_plane_flag is optional (assumed 0), but has implications
// about the ChromaArrayType, which modifies how we treat crop coordinates.
- uint32 separate_colour_plane_flag = 0;
+ uint32_t separate_colour_plane_flag = 0;
// chroma_format_idc will be ChromaArrayType if separate_colour_plane_flag is
// 0. It defaults to 1, when not specified.
- uint32 chroma_format_idc = 1;
+ uint32_t chroma_format_idc = 1;
// profile_idc: u(8). We need it to determine if we need to read/skip chroma
// formats.
- uint8 profile_idc;
+ uint8_t profile_idc;
RETURN_FALSE_ON_FAIL(parser.ReadUInt8(&profile_idc));
// constraint_set0_flag through constraint_set5_flag + reserved_zero_2bits
// 1 bit each for the flags + 2 bits = 8 bits = 1 byte.
@@ -104,12 +104,12 @@
// qpprime_y_zero_transform_bypass_flag: u(1)
RETURN_FALSE_ON_FAIL(parser.ConsumeBits(1));
// seq_scaling_matrix_present_flag: u(1)
- uint32 seq_scaling_matrix_present_flag;
+ uint32_t seq_scaling_matrix_present_flag;
RETURN_FALSE_ON_FAIL(parser.ReadBits(&seq_scaling_matrix_present_flag, 1));
if (seq_scaling_matrix_present_flag) {
// seq_scaling_list_present_flags. Either 8 or 12, depending on
// chroma_format_idc.
- uint32 seq_scaling_list_present_flags;
+ uint32_t seq_scaling_list_present_flags;
if (chroma_format_idc != 3) {
RETURN_FALSE_ON_FAIL(
parser.ReadBits(&seq_scaling_list_present_flags, 8));
@@ -129,7 +129,7 @@
// log2_max_frame_num_minus4: ue(v)
RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&golomb_ignored));
// pic_order_cnt_type: ue(v)
- uint32 pic_order_cnt_type;
+ uint32_t pic_order_cnt_type;
RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&pic_order_cnt_type));
if (pic_order_cnt_type == 0) {
// log2_max_pic_order_cnt_lsb_minus4: ue(v)
@@ -142,7 +142,7 @@
// offset_for_top_to_bottom_field: se(v)
RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&golomb_ignored));
// num_ref_frames_in_pic_order_cnt_cycle: ue(v)
- uint32 num_ref_frames_in_pic_order_cnt_cycle;
+ uint32_t num_ref_frames_in_pic_order_cnt_cycle;
RETURN_FALSE_ON_FAIL(
parser.ReadExponentialGolomb(&num_ref_frames_in_pic_order_cnt_cycle));
for (size_t i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; ++i) {
@@ -161,14 +161,14 @@
// to signify resolutions that aren't multiples of 16.
//
// pic_width_in_mbs_minus1: ue(v)
- uint32 pic_width_in_mbs_minus1;
+ uint32_t pic_width_in_mbs_minus1;
RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&pic_width_in_mbs_minus1));
// pic_height_in_map_units_minus1: ue(v)
- uint32 pic_height_in_map_units_minus1;
+ uint32_t pic_height_in_map_units_minus1;
RETURN_FALSE_ON_FAIL(
parser.ReadExponentialGolomb(&pic_height_in_map_units_minus1));
// frame_mbs_only_flag: u(1)
- uint32 frame_mbs_only_flag;
+ uint32_t frame_mbs_only_flag;
RETURN_FALSE_ON_FAIL(parser.ReadBits(&frame_mbs_only_flag, 1));
if (!frame_mbs_only_flag) {
// mb_adaptive_frame_field_flag: u(1)
@@ -180,11 +180,11 @@
// MORE IMPORTANT ONES! Now we're at the frame crop information.
//
// frame_cropping_flag: u(1)
- uint32 frame_cropping_flag;
- uint32 frame_crop_left_offset = 0;
- uint32 frame_crop_right_offset = 0;
- uint32 frame_crop_top_offset = 0;
- uint32 frame_crop_bottom_offset = 0;
+ uint32_t frame_cropping_flag;
+ uint32_t frame_crop_left_offset = 0;
+ uint32_t frame_crop_right_offset = 0;
+ uint32_t frame_crop_top_offset = 0;
+ uint32_t frame_crop_bottom_offset = 0;
RETURN_FALSE_ON_FAIL(parser.ReadBits(&frame_cropping_flag, 1));
if (frame_cropping_flag) {
// frame_crop_{left, right, top, bottom}_offset: ue(v)
diff --git a/webrtc/modules/rtp_rtcp/source/h264_sps_parser.h b/webrtc/modules/rtp_rtcp/source/h264_sps_parser.h
index ab8cca3..c05ee67 100644
--- a/webrtc/modules/rtp_rtcp/source/h264_sps_parser.h
+++ b/webrtc/modules/rtp_rtcp/source/h264_sps_parser.h
@@ -19,18 +19,18 @@
// Currently, only resolution is read without being ignored.
class H264SpsParser {
public:
- H264SpsParser(const uint8* sps, size_t byte_length);
+ H264SpsParser(const uint8_t* sps, size_t byte_length);
// Parses the SPS to completion. Returns true if the SPS was parsed correctly.
bool Parse();
- uint16 width() { return width_; }
- uint16 height() { return height_; }
+ uint16_t width() { return width_; }
+ uint16_t height() { return height_; }
private:
- const uint8* const sps_;
+ const uint8_t* const sps_;
const size_t byte_length_;
- uint16 width_;
- uint16 height_;
+ uint16_t width_;
+ uint16_t height_;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/h264_sps_parser_unittest.cc b/webrtc/modules/rtp_rtcp/source/h264_sps_parser_unittest.cc
index 621db10..ceadf4c 100644
--- a/webrtc/modules/rtp_rtcp/source/h264_sps_parser_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/h264_sps_parser_unittest.cc
@@ -38,8 +38,8 @@
// The fake SPS that this generates also always has at least one emulation byte
// at offset 2, since the first two bytes are always 0, and has a 0x3 as the
// level_idc, to make sure the parser doesn't eat all 0x3 bytes.
-void GenerateFakeSps(uint16 width, uint16 height, uint8 buffer[]) {
- uint8 rbsp[kSpsBufferMaxSize] = {0};
+void GenerateFakeSps(uint16_t width, uint16_t height, uint8_t buffer[]) {
+ uint8_t rbsp[kSpsBufferMaxSize] = {0};
rtc::BitBufferWriter writer(rbsp, kSpsBufferMaxSize);
// Profile byte.
writer.WriteUInt8(0);
@@ -63,11 +63,11 @@
// gaps_in_frame_num_value_allowed_flag: u(1).
writer.WriteBits(0, 1);
// Next are width/height. First, calculate the mbs/map_units versions.
- uint16 width_in_mbs_minus1 = (width + 15) / 16 - 1;
+ uint16_t width_in_mbs_minus1 = (width + 15) / 16 - 1;
// For the height, we're going to define frame_mbs_only_flag, so we need to
// divide by 2. See the parser for the full calculation.
- uint16 height_in_map_units_minus1 = ((height + 15) / 16 - 1) / 2;
+ uint16_t height_in_map_units_minus1 = ((height + 15) / 16 - 1) / 2;
// Write each as ue(v).
writer.WriteExponentialGolomb(width_in_mbs_minus1);
writer.WriteExponentialGolomb(height_in_map_units_minus1);
@@ -118,9 +118,9 @@
TEST(H264SpsParserTest, TestSampleSPSHdLandscape) {
// SPS for a 1280x720 camera capture from ffmpeg on osx. Contains
// emulation bytes but no cropping.
- const uint8 buffer[] = {0x7A, 0x00, 0x1F, 0xBC, 0xD9, 0x40, 0x50, 0x05,
- 0xBA, 0x10, 0x00, 0x00, 0x03, 0x00, 0xC0, 0x00,
- 0x00, 0x2A, 0xE0, 0xF1, 0x83, 0x19, 0x60};
+ const uint8_t buffer[] = {0x7A, 0x00, 0x1F, 0xBC, 0xD9, 0x40, 0x50, 0x05,
+ 0xBA, 0x10, 0x00, 0x00, 0x03, 0x00, 0xC0, 0x00,
+ 0x00, 0x2A, 0xE0, 0xF1, 0x83, 0x19, 0x60};
H264SpsParser parser = H264SpsParser(buffer, ARRAY_SIZE(buffer));
EXPECT_TRUE(parser.Parse());
EXPECT_EQ(1280u, parser.width());
@@ -130,9 +130,9 @@
TEST(H264SpsParserTest, TestSampleSPSVgaLandscape) {
// SPS for a 640x360 camera capture from ffmpeg on osx. Contains emulation
// bytes and cropping (360 isn't divisible by 16).
- const uint8 buffer[] = {0x7A, 0x00, 0x1E, 0xBC, 0xD9, 0x40, 0xA0, 0x2F,
- 0xF8, 0x98, 0x40, 0x00, 0x00, 0x03, 0x01, 0x80,
- 0x00, 0x00, 0x56, 0x83, 0xC5, 0x8B, 0x65, 0x80};
+ const uint8_t buffer[] = {0x7A, 0x00, 0x1E, 0xBC, 0xD9, 0x40, 0xA0, 0x2F,
+ 0xF8, 0x98, 0x40, 0x00, 0x00, 0x03, 0x01, 0x80,
+ 0x00, 0x00, 0x56, 0x83, 0xC5, 0x8B, 0x65, 0x80};
H264SpsParser parser = H264SpsParser(buffer, ARRAY_SIZE(buffer));
EXPECT_TRUE(parser.Parse());
EXPECT_EQ(640u, parser.width());
@@ -142,9 +142,9 @@
TEST(H264SpsParserTest, TestSampleSPSWeirdResolution) {
// SPS for a 200x400 camera capture from ffmpeg on osx. Horizontal and
// veritcal crop (neither dimension is divisible by 16).
- const uint8 buffer[] = {0x7A, 0x00, 0x0D, 0xBC, 0xD9, 0x43, 0x43, 0x3E,
- 0x5E, 0x10, 0x00, 0x00, 0x03, 0x00, 0x60, 0x00,
- 0x00, 0x15, 0xA0, 0xF1, 0x42, 0x99, 0x60};
+ const uint8_t buffer[] = {0x7A, 0x00, 0x0D, 0xBC, 0xD9, 0x43, 0x43, 0x3E,
+ 0x5E, 0x10, 0x00, 0x00, 0x03, 0x00, 0x60, 0x00,
+ 0x00, 0x15, 0xA0, 0xF1, 0x42, 0x99, 0x60};
H264SpsParser parser = H264SpsParser(buffer, ARRAY_SIZE(buffer));
EXPECT_TRUE(parser.Parse());
EXPECT_EQ(200u, parser.width());
@@ -152,7 +152,7 @@
}
TEST(H264SpsParserTest, TestSyntheticSPSQvgaLandscape) {
- uint8 buffer[kSpsBufferMaxSize] = {0};
+ uint8_t buffer[kSpsBufferMaxSize] = {0};
GenerateFakeSps(320u, 180u, buffer);
H264SpsParser parser = H264SpsParser(buffer, ARRAY_SIZE(buffer));
EXPECT_TRUE(parser.Parse());
@@ -161,7 +161,7 @@
}
TEST(H264SpsParserTest, TestSyntheticSPSWeirdResolution) {
- uint8 buffer[kSpsBufferMaxSize] = {0};
+ uint8_t buffer[kSpsBufferMaxSize] = {0};
GenerateFakeSps(156u, 122u, buffer);
H264SpsParser parser = H264SpsParser(buffer, ARRAY_SIZE(buffer));
EXPECT_TRUE(parser.Parse());
diff --git a/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_decoder.cc b/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_decoder.cc
index 36646a9..61ef80b 100644
--- a/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_decoder.cc
+++ b/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_decoder.cc
@@ -56,10 +56,10 @@
rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer =
new rtc::RefCountedObject<webrtc::I420Buffer>(width, height);
CVPixelBufferLockBaseAddress(pixel_buffer, kCVPixelBufferLock_ReadOnly);
- const uint8* src_y = reinterpret_cast<const uint8*>(
+ const uint8_t* src_y = reinterpret_cast<const uint8_t*>(
CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, 0));
int src_y_stride = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, 0);
- const uint8* src_uv = reinterpret_cast<const uint8*>(
+ const uint8_t* src_uv = reinterpret_cast<const uint8_t*>(
CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, 1));
int src_uv_stride = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, 1);
int ret = libyuv::NV12ToI420(
diff --git a/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.cc b/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.cc
index fec3226..69e52a5 100644
--- a/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.cc
+++ b/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.cc
@@ -136,10 +136,10 @@
LOG(LS_ERROR) << "Failed to lock base address: " << cvRet;
return false;
}
- uint8* dst_y = reinterpret_cast<uint8*>(
+ uint8_t* dst_y = reinterpret_cast<uint8_t*>(
CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, 0));
int dst_stride_y = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, 0);
- uint8* dst_uv = reinterpret_cast<uint8*>(
+ uint8_t* dst_uv = reinterpret_cast<uint8_t*>(
CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, 1));
int dst_stride_uv = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, 1);
// Convert I420 to NV12.
diff --git a/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu.cc b/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu.cc
index 43a7de0..caca96d 100644
--- a/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu.cc
+++ b/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu.cc
@@ -123,7 +123,7 @@
// Read the length of the next packet of data. Must convert from big endian
// to host endian.
RTC_DCHECK_GE(bytes_remaining, (size_t)nalu_header_size);
- uint32_t* uint32_data_ptr = reinterpret_cast<uint32*>(data_ptr);
+ uint32_t* uint32_data_ptr = reinterpret_cast<uint32_t*>(data_ptr);
uint32_t packet_size = CFSwapInt32BigToHost(*uint32_data_ptr);
// Update buffer.
annexb_buffer->AppendData(kAnnexBHeaderBytes, sizeof(kAnnexBHeaderBytes));
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
index f1a069d..672fa3a 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
@@ -848,7 +848,7 @@
// 3rd stream: -1, -1, -1, -1, ....
// Regarding the 3rd stream, note that a stream/encoder with 1 temporal layer
// should always have temporal layer idx set to kNoTemporalIdx = -1.
- // Since CodecSpecificInfoVP8.temporalIdx is uint8, this will wrap to 255.
+ // Since CodecSpecificInfoVP8.temporalIdx is uint8_t, this will wrap to 255.
// TODO(marpan): Although this seems safe for now, we should fix this.
void TestSpatioTemporalLayers321PatternEncoder() {
int temporal_layer_profile[3] = {3, 2, 1};
diff --git a/webrtc/modules/video_coding/codecs/vp9/vp9_frame_buffer_pool.cc b/webrtc/modules/video_coding/codecs/vp9/vp9_frame_buffer_pool.cc
index ce600ec..239ced8 100644
--- a/webrtc/modules/video_coding/codecs/vp9/vp9_frame_buffer_pool.cc
+++ b/webrtc/modules/video_coding/codecs/vp9/vp9_frame_buffer_pool.cc
@@ -98,9 +98,9 @@
}
// static
-int32 Vp9FrameBufferPool::VpxGetFrameBuffer(void* user_priv,
- size_t min_size,
- vpx_codec_frame_buffer* fb) {
+int32_t Vp9FrameBufferPool::VpxGetFrameBuffer(void* user_priv,
+ size_t min_size,
+ vpx_codec_frame_buffer* fb) {
RTC_DCHECK(user_priv);
RTC_DCHECK(fb);
Vp9FrameBufferPool* pool = static_cast<Vp9FrameBufferPool*>(user_priv);
@@ -118,8 +118,8 @@
}
// static
-int32 Vp9FrameBufferPool::VpxReleaseFrameBuffer(void* user_priv,
- vpx_codec_frame_buffer* fb) {
+int32_t Vp9FrameBufferPool::VpxReleaseFrameBuffer(void* user_priv,
+ vpx_codec_frame_buffer* fb) {
RTC_DCHECK(user_priv);
RTC_DCHECK(fb);
Vp9FrameBuffer* buffer = static_cast<Vp9FrameBuffer*>(fb->priv);
diff --git a/webrtc/modules/video_coding/codecs/vp9/vp9_frame_buffer_pool.h b/webrtc/modules/video_coding/codecs/vp9/vp9_frame_buffer_pool.h
index 1ee5124..97ed41a 100644
--- a/webrtc/modules/video_coding/codecs/vp9/vp9_frame_buffer_pool.h
+++ b/webrtc/modules/video_coding/codecs/vp9/vp9_frame_buffer_pool.h
@@ -88,9 +88,9 @@
// |fb| Pointer to the libvpx frame buffer object, this is updated to
// use the pool's buffer.
// Returns 0 on success. Returns < 0 on failure.
- static int32 VpxGetFrameBuffer(void* user_priv,
- size_t min_size,
- vpx_codec_frame_buffer* fb);
+ static int32_t VpxGetFrameBuffer(void* user_priv,
+ size_t min_size,
+ vpx_codec_frame_buffer* fb);
// InitializeVpxUsePool configures libvpx to call this function when it has
// finished using one of the pool's frame buffer. Parameters:
@@ -98,8 +98,8 @@
// to be a pointer to the pool.
// |fb| Pointer to the libvpx frame buffer object, its |priv| will be
// a pointer to one of the pool's Vp9FrameBuffer.
- static int32 VpxReleaseFrameBuffer(void* user_priv,
- vpx_codec_frame_buffer* fb);
+ static int32_t VpxReleaseFrameBuffer(void* user_priv,
+ vpx_codec_frame_buffer* fb);
private:
// Protects |allocated_buffers_|.
diff --git a/webrtc/p2p/base/asyncstuntcpsocket.cc b/webrtc/p2p/base/asyncstuntcpsocket.cc
index 2b1b693..444f061 100644
--- a/webrtc/p2p/base/asyncstuntcpsocket.cc
+++ b/webrtc/p2p/base/asyncstuntcpsocket.cc
@@ -20,13 +20,13 @@
static const size_t kMaxPacketSize = 64 * 1024;
-typedef uint16 PacketLength;
+typedef uint16_t PacketLength;
static const size_t kPacketLenSize = sizeof(PacketLength);
static const size_t kPacketLenOffset = 2;
static const size_t kBufSize = kMaxPacketSize + kStunHeaderSize;
static const size_t kTurnChannelDataHdrSize = 4;
-inline bool IsStunMessage(uint16 msg_type) {
+inline bool IsStunMessage(uint16_t msg_type) {
// The first two bits of a channel data message are 0b01.
return (msg_type & 0xC000) ? false : true;
}
@@ -129,7 +129,7 @@
PacketLength pkt_len =
rtc::GetBE16(static_cast<const char*>(data) + kPacketLenOffset);
size_t expected_pkt_len;
- uint16 msg_type = rtc::GetBE16(data);
+ uint16_t msg_type = rtc::GetBE16(data);
if (IsStunMessage(msg_type)) {
// STUN message.
expected_pkt_len = kStunHeaderSize + pkt_len;
diff --git a/webrtc/p2p/base/basicpacketsocketfactory.cc b/webrtc/p2p/base/basicpacketsocketfactory.cc
index 9b12e78d..697518d 100644
--- a/webrtc/p2p/base/basicpacketsocketfactory.cc
+++ b/webrtc/p2p/base/basicpacketsocketfactory.cc
@@ -44,7 +44,9 @@
}
AsyncPacketSocket* BasicPacketSocketFactory::CreateUdpSocket(
- const SocketAddress& address, uint16 min_port, uint16 max_port) {
+ const SocketAddress& address,
+ uint16_t min_port,
+ uint16_t max_port) {
// UDP sockets are simple.
rtc::AsyncSocket* socket =
socket_factory()->CreateAsyncSocket(
@@ -62,9 +64,10 @@
}
AsyncPacketSocket* BasicPacketSocketFactory::CreateServerTcpSocket(
- const SocketAddress& local_address, uint16 min_port, uint16 max_port,
+ const SocketAddress& local_address,
+ uint16_t min_port,
+ uint16_t max_port,
int opts) {
-
// Fail if TLS is required.
if (opts & PacketSocketFactory::OPT_TLS) {
LOG(LS_ERROR) << "TLS support currently is not available.";
@@ -176,9 +179,10 @@
return new rtc::AsyncResolver();
}
-int BasicPacketSocketFactory::BindSocket(
- AsyncSocket* socket, const SocketAddress& local_address,
- uint16 min_port, uint16 max_port) {
+int BasicPacketSocketFactory::BindSocket(AsyncSocket* socket,
+ const SocketAddress& local_address,
+ uint16_t min_port,
+ uint16_t max_port) {
int ret = -1;
if (min_port == 0 && max_port == 0) {
// If there's no port range, let the OS pick a port for us.
diff --git a/webrtc/p2p/base/basicpacketsocketfactory.h b/webrtc/p2p/base/basicpacketsocketfactory.h
index b23a677..5046e0f 100644
--- a/webrtc/p2p/base/basicpacketsocketfactory.h
+++ b/webrtc/p2p/base/basicpacketsocketfactory.h
@@ -27,11 +27,11 @@
~BasicPacketSocketFactory() override;
AsyncPacketSocket* CreateUdpSocket(const SocketAddress& local_address,
- uint16 min_port,
- uint16 max_port) override;
+ uint16_t min_port,
+ uint16_t max_port) override;
AsyncPacketSocket* CreateServerTcpSocket(const SocketAddress& local_address,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
int opts) override;
AsyncPacketSocket* CreateClientTcpSocket(const SocketAddress& local_address,
const SocketAddress& remote_address,
@@ -44,8 +44,8 @@
private:
int BindSocket(AsyncSocket* socket,
const SocketAddress& local_address,
- uint16 min_port,
- uint16 max_port);
+ uint16_t min_port,
+ uint16_t max_port);
SocketFactory* socket_factory();
diff --git a/webrtc/p2p/base/candidate.h b/webrtc/p2p/base/candidate.h
index 2655c1b..3f0ea43 100644
--- a/webrtc/p2p/base/candidate.h
+++ b/webrtc/p2p/base/candidate.h
@@ -43,11 +43,11 @@
Candidate(int component,
const std::string& protocol,
const rtc::SocketAddress& address,
- uint32 priority,
+ uint32_t priority,
const std::string& username,
const std::string& password,
const std::string& type,
- uint32 generation,
+ uint32_t generation,
const std::string& foundation)
: id_(rtc::CreateRandomString(8)),
component_(component),
@@ -81,8 +81,8 @@
address_ = address;
}
- uint32 priority() const { return priority_; }
- void set_priority(const uint32 priority) { priority_ = priority; }
+ uint32_t priority() const { return priority_; }
+ void set_priority(const uint32_t priority) { priority_ = priority; }
// TODO(pthatcher): Remove once Chromium's jingle/glue/utils.cc
// doesn't use it.
@@ -98,11 +98,11 @@
// TODO(pthatcher): Remove once Chromium's jingle/glue/utils.cc
// doesn't use it.
void set_preference(float preference) {
- // Limiting priority to UINT_MAX when value exceeds uint32 max.
+ // Limiting priority to UINT_MAX when value exceeds uint32_t max.
// This can happen for e.g. when preference = 3.
- uint64 prio_val = static_cast<uint64>(preference * 127) << 24;
- priority_ =
- static_cast<uint32>(std::min(prio_val, static_cast<uint64>(UINT_MAX)));
+ uint64_t prio_val = static_cast<uint64_t>(preference * 127) << 24;
+ priority_ = static_cast<uint32_t>(
+ std::min(prio_val, static_cast<uint64_t>(UINT_MAX)));
}
const std::string & username() const { return username_; }
@@ -125,8 +125,8 @@
}
// Candidates in a new generation replace those in the old generation.
- uint32 generation() const { return generation_; }
- void set_generation(uint32 generation) { generation_ = generation; }
+ uint32_t generation() const { return generation_; }
+ void set_generation(uint32_t generation) { generation_ = generation; }
const std::string generation_str() const {
std::ostringstream ost;
ost << generation_;
@@ -177,9 +177,9 @@
return ToStringInternal(true);
}
- uint32 GetPriority(uint32 type_preference,
- int network_adapter_preference,
- int relay_preference) const {
+ uint32_t GetPriority(uint32_t type_preference,
+ int network_adapter_preference,
+ int relay_preference) const {
// RFC 5245 - 4.1.2.1.
// priority = (2^24)*(type preference) +
// (2^8)*(local preference) +
@@ -222,13 +222,13 @@
std::string protocol_;
std::string relay_protocol_;
rtc::SocketAddress address_;
- uint32 priority_;
+ uint32_t priority_;
std::string username_;
std::string password_;
std::string type_;
std::string network_name_;
rtc::AdapterType network_type_;
- uint32 generation_;
+ uint32_t generation_;
std::string foundation_;
rtc::SocketAddress related_address_;
std::string tcptype_;
diff --git a/webrtc/p2p/base/dtlstransport.h b/webrtc/p2p/base/dtlstransport.h
index c448eb1..e9a1ae2 100644
--- a/webrtc/p2p/base/dtlstransport.h
+++ b/webrtc/p2p/base/dtlstransport.h
@@ -229,10 +229,10 @@
error_desc);
}
// Apply remote fingerprint.
- if (!channel->SetRemoteFingerprint(
- remote_fingerprint_->algorithm,
- reinterpret_cast<const uint8*>(remote_fingerprint_->digest.data()),
- remote_fingerprint_->digest.size())) {
+ if (!channel->SetRemoteFingerprint(remote_fingerprint_->algorithm,
+ reinterpret_cast<const uint8_t*>(
+ remote_fingerprint_->digest.data()),
+ remote_fingerprint_->digest.size())) {
return BadTransportDescription("Failed to apply remote fingerprint.",
error_desc);
}
diff --git a/webrtc/p2p/base/dtlstransportchannel.cc b/webrtc/p2p/base/dtlstransportchannel.cc
index 26bb181..bba7eb9 100644
--- a/webrtc/p2p/base/dtlstransportchannel.cc
+++ b/webrtc/p2p/base/dtlstransportchannel.cc
@@ -31,11 +31,11 @@
static const size_t kMaxPendingPackets = 1;
static bool IsDtlsPacket(const char* data, size_t len) {
- const uint8* u = reinterpret_cast<const uint8*>(data);
+ const uint8_t* u = reinterpret_cast<const uint8_t*>(data);
return (len >= kDtlsRecordHeaderLen && (u[0] > 19 && u[0] < 64));
}
static bool IsRtpPacket(const char* data, size_t len) {
- const uint8* u = reinterpret_cast<const uint8*>(data);
+ const uint8_t* u = reinterpret_cast<const uint8_t*>(data);
return (len >= kMinRtpPacketLen && (u[0] & 0xC0) == 0x80);
}
@@ -196,9 +196,8 @@
bool DtlsTransportChannelWrapper::SetRemoteFingerprint(
const std::string& digest_alg,
- const uint8* digest,
+ const uint8_t* digest,
size_t digest_len) {
-
rtc::Buffer remote_fingerprint_value(digest, digest_len);
if (dtls_state_ != STATE_NONE &&
@@ -570,7 +569,7 @@
size_t size) {
// Sanity check we're not passing junk that
// just looks like DTLS.
- const uint8* tmp_data = reinterpret_cast<const uint8* >(data);
+ const uint8_t* tmp_data = reinterpret_cast<const uint8_t*>(data);
size_t tmp_size = size;
while (tmp_size > 0) {
if (tmp_size < kDtlsRecordHeaderLen)
diff --git a/webrtc/p2p/base/dtlstransportchannel.h b/webrtc/p2p/base/dtlstransportchannel.h
index d27d30e..9a2ccde 100644
--- a/webrtc/p2p/base/dtlstransportchannel.h
+++ b/webrtc/p2p/base/dtlstransportchannel.h
@@ -104,7 +104,7 @@
rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate() const override;
bool SetRemoteFingerprint(const std::string& digest_alg,
- const uint8* digest,
+ const uint8_t* digest,
size_t digest_len) override;
bool IsDtlsActive() const override { return dtls_state_ != STATE_NONE; }
@@ -152,10 +152,10 @@
// encryption. DTLS-SRTP uses this to extract the needed SRTP keys.
// See the SSLStreamAdapter documentation for info on the specific parameters.
bool ExportKeyingMaterial(const std::string& label,
- const uint8* context,
+ const uint8_t* context,
size_t context_len,
bool use_context,
- uint8* result,
+ uint8_t* result,
size_t result_len) override {
return (dtls_.get()) ? dtls_->ExportKeyingMaterial(label, context,
context_len,
@@ -170,7 +170,7 @@
TransportChannelState GetState() const override {
return channel_->GetState();
}
- void SetIceTiebreaker(uint64 tiebreaker) override {
+ void SetIceTiebreaker(uint64_t tiebreaker) override {
channel_->SetIceTiebreaker(tiebreaker);
}
void SetIceCredentials(const std::string& ice_ufrag,
diff --git a/webrtc/p2p/base/dtlstransportchannel_unittest.cc b/webrtc/p2p/base/dtlstransportchannel_unittest.cc
index cad5b56..460e294 100644
--- a/webrtc/p2p/base/dtlstransportchannel_unittest.cc
+++ b/webrtc/p2p/base/dtlstransportchannel_unittest.cc
@@ -34,7 +34,7 @@
static const size_t kPacketNumOffset = 8;
static const size_t kPacketHeaderLen = 12;
-static bool IsRtpLeadByte(uint8 b) {
+static bool IsRtpLeadByte(uint8_t b) {
return ((b & 0xC0) == 0x80);
}
@@ -254,7 +254,7 @@
memset(packet.get(), sent & 0xff, size);
packet[0] = (srtp) ? 0x80 : 0x00;
rtc::SetBE32(packet.get() + kPacketNumOffset,
- static_cast<uint32>(sent));
+ static_cast<uint32_t>(sent));
// Only set the bypass flag if we've activated DTLS.
int flags = (certificate_ && srtp) ? cricket::PF_SRTP_BYPASS : 0;
@@ -287,14 +287,14 @@
return received_.size();
}
- bool VerifyPacket(const char* data, size_t size, uint32* out_num) {
+ bool VerifyPacket(const char* data, size_t size, uint32_t* out_num) {
if (size != packet_size_ ||
- (data[0] != 0 && static_cast<uint8>(data[0]) != 0x80)) {
+ (data[0] != 0 && static_cast<uint8_t>(data[0]) != 0x80)) {
return false;
}
- uint32 packet_num = rtc::GetBE32(data + kPacketNumOffset);
+ uint32_t packet_num = rtc::GetBE32(data + kPacketNumOffset);
for (size_t i = kPacketHeaderLen; i < size; ++i) {
- if (static_cast<uint8>(data[i]) != (packet_num & 0xff)) {
+ if (static_cast<uint8_t>(data[i]) != (packet_num & 0xff)) {
return false;
}
}
@@ -309,10 +309,10 @@
if (size <= packet_size_) {
return false;
}
- uint32 packet_num = rtc::GetBE32(data + kPacketNumOffset);
+ uint32_t packet_num = rtc::GetBE32(data + kPacketNumOffset);
int num_matches = 0;
for (size_t i = kPacketNumOffset; i < size; ++i) {
- if (static_cast<uint8>(data[i]) == (packet_num & 0xff)) {
+ if (static_cast<uint8_t>(data[i]) == (packet_num & 0xff)) {
++num_matches;
}
}
@@ -329,7 +329,7 @@
const char* data, size_t size,
const rtc::PacketTime& packet_time,
int flags) {
- uint32 packet_num = 0;
+ uint32_t packet_num = 0;
ASSERT_TRUE(VerifyPacket(data, size, &packet_num));
received_.insert(packet_num);
// Only DTLS-SRTP packets should have the bypass flag set.
diff --git a/webrtc/p2p/base/faketransportcontroller.h b/webrtc/p2p/base/faketransportcontroller.h
index 6d337a4..7d8e3d7 100644
--- a/webrtc/p2p/base/faketransportcontroller.h
+++ b/webrtc/p2p/base/faketransportcontroller.h
@@ -51,7 +51,7 @@
dtls_fingerprint_("", nullptr, 0) {}
~FakeTransportChannel() { Reset(); }
- uint64 IceTiebreaker() const { return tiebreaker_; }
+ uint64_t IceTiebreaker() const { return tiebreaker_; }
IceMode remote_ice_mode() const { return remote_ice_mode_; }
const std::string& ice_ufrag() const { return ice_ufrag_; }
const std::string& ice_pwd() const { return ice_pwd_; }
@@ -82,7 +82,7 @@
void SetIceRole(IceRole role) override { role_ = role; }
IceRole GetIceRole() const override { return role_; }
- void SetIceTiebreaker(uint64 tiebreaker) override {
+ void SetIceTiebreaker(uint64_t tiebreaker) override {
tiebreaker_ = tiebreaker;
}
void SetIceCredentials(const std::string& ice_ufrag,
@@ -98,7 +98,7 @@
void SetRemoteIceMode(IceMode mode) override { remote_ice_mode_ = mode; }
bool SetRemoteFingerprint(const std::string& alg,
- const uint8* digest,
+ const uint8_t* digest,
size_t digest_len) override {
dtls_fingerprint_ = rtc::SSLFingerprint(alg, digest, digest_len);
return true;
@@ -266,10 +266,10 @@
}
bool ExportKeyingMaterial(const std::string& label,
- const uint8* context,
+ const uint8_t* context,
size_t context_len,
bool use_context,
- uint8* result,
+ uint8_t* result,
size_t result_len) override {
if (!chosen_srtp_cipher_.empty()) {
memset(result, 0xff, result_len);
@@ -323,7 +323,7 @@
int receiving_timeout_ = -1;
bool gather_continually_ = false;
IceRole role_ = ICEROLE_UNKNOWN;
- uint64 tiebreaker_ = 0;
+ uint64_t tiebreaker_ = 0;
std::string ice_ufrag_;
std::string ice_pwd_;
std::string remote_ice_ufrag_;
diff --git a/webrtc/p2p/base/p2ptransportchannel.cc b/webrtc/p2p/base/p2ptransportchannel.cc
index 1b7cb58..fc72131 100644
--- a/webrtc/p2p/base/p2ptransportchannel.cc
+++ b/webrtc/p2p/base/p2ptransportchannel.cc
@@ -30,18 +30,18 @@
// we don't want to degrade the quality on a modem. These numbers should work
// well on a 28.8K modem, which is the slowest connection on which the voice
// quality is reasonable at all.
-static const uint32 PING_PACKET_SIZE = 60 * 8;
+static const uint32_t PING_PACKET_SIZE = 60 * 8;
// STRONG_PING_DELAY (480ms) is applied when the best connection is both
// writable and receiving.
-static const uint32 STRONG_PING_DELAY = 1000 * PING_PACKET_SIZE / 1000;
+static const uint32_t STRONG_PING_DELAY = 1000 * PING_PACKET_SIZE / 1000;
// WEAK_PING_DELAY (48ms) is applied when the best connection is either not
// writable or not receiving.
-static const uint32 WEAK_PING_DELAY = 1000 * PING_PACKET_SIZE / 10000;
+static const uint32_t WEAK_PING_DELAY = 1000 * PING_PACKET_SIZE / 10000;
// If the current best connection is both writable and receiving, then we will
// also try hard to make sure it is pinged at this rate (a little less than
// 2 * STRONG_PING_DELAY).
-static const uint32 MAX_CURRENT_STRONG_DELAY = 900;
+static const uint32_t MAX_CURRENT_STRONG_DELAY = 900;
static const int MIN_CHECK_RECEIVING_DELAY = 50; // ms
@@ -225,14 +225,14 @@
P2PTransportChannel::~P2PTransportChannel() {
ASSERT(worker_thread_ == rtc::Thread::Current());
- for (uint32 i = 0; i < allocator_sessions_.size(); ++i)
+ for (size_t i = 0; i < allocator_sessions_.size(); ++i)
delete allocator_sessions_[i];
}
// Add the allocator session to our list so that we know which sessions
// are still active.
void P2PTransportChannel::AddAllocatorSession(PortAllocatorSession* session) {
- session->set_generation(static_cast<uint32>(allocator_sessions_.size()));
+ session->set_generation(static_cast<uint32_t>(allocator_sessions_.size()));
allocator_sessions_.push_back(session);
// We now only want to apply new candidates that we receive to the ports
@@ -275,7 +275,7 @@
}
}
-void P2PTransportChannel::SetIceTiebreaker(uint64 tiebreaker) {
+void P2PTransportChannel::SetIceTiebreaker(uint64_t tiebreaker) {
ASSERT(worker_thread_ == rtc::Thread::Current());
if (!ports_.empty()) {
LOG(LS_ERROR)
@@ -553,7 +553,7 @@
// The foundation of the candidate is set to an arbitrary value, different
// from the foundation for all other remote candidates.
remote_candidate.set_foundation(
- rtc::ToString<uint32>(rtc::ComputeCrc32(remote_candidate.id())));
+ rtc::ToString<uint32_t>(rtc::ComputeCrc32(remote_candidate.id())));
remote_candidate.set_priority(remote_candidate_priority);
}
@@ -638,7 +638,7 @@
void P2PTransportChannel::AddRemoteCandidate(const Candidate& candidate) {
ASSERT(worker_thread_ == rtc::Thread::Current());
- uint32 generation = candidate.generation();
+ uint32_t generation = candidate.generation();
// Network may not guarantee the order of the candidate delivery. If a
// remote candidate with an older generation arrives, drop it.
if (generation != 0 && generation < remote_candidate_generation_) {
@@ -765,7 +765,7 @@
return citer != connections_.end();
}
-uint32 P2PTransportChannel::GetRemoteCandidateGeneration(
+uint32_t P2PTransportChannel::GetRemoteCandidateGeneration(
const Candidate& candidate) {
// We need to keep track of the remote ice restart so newer
// connections are prioritized over the older.
@@ -777,7 +777,7 @@
// Check if remote candidate is already cached.
bool P2PTransportChannel::IsDuplicateRemoteCandidate(
const Candidate& candidate) {
- for (uint32 i = 0; i < remote_candidates_.size(); ++i) {
+ for (size_t i = 0; i < remote_candidates_.size(); ++i) {
if (remote_candidates_[i].IsEquivalent(candidate)) {
return true;
}
@@ -790,7 +790,7 @@
const Candidate& remote_candidate, PortInterface* origin_port) {
// Remove any candidates whose generation is older than this one. The
// presence of a new generation indicates that the old ones are not useful.
- uint32 i = 0;
+ size_t i = 0;
while (i < remote_candidates_.size()) {
if (remote_candidates_[i].generation() < remote_candidate.generation()) {
LOG(INFO) << "Pruning candidate from old generation: "
@@ -824,7 +824,7 @@
it->second = value;
}
- for (uint32 i = 0; i < ports_.size(); ++i) {
+ for (size_t i = 0; i < ports_.size(); ++i) {
int val = ports_[i]->SetOption(opt, value);
if (val < 0) {
// Because this also occurs deferred, probably no point in reporting an
@@ -911,11 +911,11 @@
// Monitor connection states.
void P2PTransportChannel::UpdateConnectionStates() {
- uint32 now = rtc::Time();
+ uint32_t now = rtc::Time();
// We need to copy the list of connections since some may delete themselves
// when we call UpdateState.
- for (uint32 i = 0; i < connections_.size(); ++i)
+ for (size_t i = 0; i < connections_.size(); ++i)
connections_[i]->UpdateState(now);
}
@@ -947,7 +947,7 @@
std::stable_sort(connections_.begin(), connections_.end(), cmp);
LOG(LS_VERBOSE) << "Sorting " << connections_.size()
<< " available connections:";
- for (uint32 i = 0; i < connections_.size(); ++i) {
+ for (size_t i = 0; i < connections_.size(); ++i) {
LOG(LS_VERBOSE) << connections_[i]->ToString();
}
@@ -971,7 +971,7 @@
// Check if all connections are timedout.
bool all_connections_timedout = true;
- for (uint32 i = 0; i < connections_.size(); ++i) {
+ for (size_t i = 0; i < connections_.size(); ++i) {
if (connections_[i]->write_state() != Connection::STATE_WRITE_TIMEOUT) {
all_connections_timedout = false;
break;
@@ -1120,7 +1120,7 @@
return best_connection_;
// Otherwise, we return the top-most in sorted order.
- for (uint32 i = 0; i < connections_.size(); ++i) {
+ for (size_t i = 0; i < connections_.size(); ++i) {
if (connections_[i]->port()->Network() == network)
return connections_[i];
}
@@ -1198,7 +1198,7 @@
// reconnecting. The newly created connection should be selected as the ping
// target to become writable instead. See the big comment in CompareConnections.
Connection* P2PTransportChannel::FindNextPingableConnection() {
- uint32 now = rtc::Time();
+ uint32_t now = rtc::Time();
if (best_connection_ && best_connection_->connected() &&
best_connection_->writable() &&
(best_connection_->last_ping_sent() + MAX_CURRENT_STRONG_DELAY <= now)) {
diff --git a/webrtc/p2p/base/p2ptransportchannel.h b/webrtc/p2p/base/p2ptransportchannel.h
index 0e5e019..5249639 100644
--- a/webrtc/p2p/base/p2ptransportchannel.h
+++ b/webrtc/p2p/base/p2ptransportchannel.h
@@ -62,7 +62,7 @@
TransportChannelState GetState() const override;
void SetIceRole(IceRole role) override;
IceRole GetIceRole() const override { return ice_role_; }
- void SetIceTiebreaker(uint64 tiebreaker) override;
+ void SetIceTiebreaker(uint64_t tiebreaker) override;
void SetIceCredentials(const std::string& ice_ufrag,
const std::string& ice_pwd) override;
void SetRemoteIceCredentials(const std::string& ice_ufrag,
@@ -127,10 +127,10 @@
// Allows key material to be extracted for external encryption.
bool ExportKeyingMaterial(const std::string& label,
- const uint8* context,
+ const uint8_t* context,
size_t context_len,
bool use_context,
- uint8* result,
+ uint8_t* result,
size_t result_len) override {
return false;
}
@@ -142,7 +142,7 @@
// Set DTLS Remote fingerprint. Must be after local identity set.
bool SetRemoteFingerprint(const std::string& digest_alg,
- const uint8* digest,
+ const uint8_t* digest,
size_t digest_len) override {
return false;
}
@@ -182,7 +182,7 @@
PortInterface* origin_port);
bool FindConnection(cricket::Connection* connection) const;
- uint32 GetRemoteCandidateGeneration(const Candidate& candidate);
+ uint32_t GetRemoteCandidateGeneration(const Candidate& candidate);
bool IsDuplicateRemoteCandidate(const Candidate& candidate);
void RememberRemoteCandidate(const Candidate& remote_candidate,
PortInterface* origin_port);
@@ -243,13 +243,13 @@
std::string remote_ice_pwd_;
IceMode remote_ice_mode_;
IceRole ice_role_;
- uint64 tiebreaker_;
- uint32 remote_candidate_generation_;
+ uint64_t tiebreaker_;
+ uint32_t remote_candidate_generation_;
IceGatheringState gathering_state_;
int check_receiving_delay_;
int receiving_timeout_;
- uint32 last_ping_sent_ms_ = 0;
+ uint32_t last_ping_sent_ms_ = 0;
bool gather_continually_ = false;
RTC_DISALLOW_COPY_AND_ASSIGN(P2PTransportChannel);
diff --git a/webrtc/p2p/base/p2ptransportchannel_unittest.cc b/webrtc/p2p/base/p2ptransportchannel_unittest.cc
index 56635dc..86f4ec3 100644
--- a/webrtc/p2p/base/p2ptransportchannel_unittest.cc
+++ b/webrtc/p2p/base/p2ptransportchannel_unittest.cc
@@ -93,8 +93,8 @@
"TESTICEPWD00000000000002",
"TESTICEPWD00000000000003"};
-static const uint64 kTiebreaker1 = 11111;
-static const uint64 kTiebreaker2 = 22222;
+static const uint64_t kTiebreaker1 = 11111;
+static const uint64_t kTiebreaker2 = 22222;
enum {
MSG_CANDIDATE
@@ -239,11 +239,11 @@
void SetIceRole(cricket::IceRole role) { role_ = role; }
cricket::IceRole ice_role() { return role_; }
- void SetIceTiebreaker(uint64 tiebreaker) { tiebreaker_ = tiebreaker; }
- uint64 GetIceTiebreaker() { return tiebreaker_; }
+ void SetIceTiebreaker(uint64_t tiebreaker) { tiebreaker_ = tiebreaker; }
+ uint64_t GetIceTiebreaker() { return tiebreaker_; }
void OnRoleConflict(bool role_conflict) { role_conflict_ = role_conflict; }
bool role_conflict() { return role_conflict_; }
- void SetAllocationStepDelay(uint32 delay) {
+ void SetAllocationStepDelay(uint32_t delay) {
allocator_->set_step_delay(delay);
}
void SetAllowTcpListen(bool allow_tcp_listen) {
@@ -255,7 +255,7 @@
ChannelData cd1_;
ChannelData cd2_;
cricket::IceRole role_;
- uint64 tiebreaker_;
+ uint64_t tiebreaker_;
bool role_conflict_;
bool save_candidates_;
std::vector<CandidateData*> saved_candidates_;
@@ -382,13 +382,13 @@
void SetIceRole(int endpoint, cricket::IceRole role) {
GetEndpoint(endpoint)->SetIceRole(role);
}
- void SetIceTiebreaker(int endpoint, uint64 tiebreaker) {
+ void SetIceTiebreaker(int endpoint, uint64_t tiebreaker) {
GetEndpoint(endpoint)->SetIceTiebreaker(tiebreaker);
}
bool GetRoleConflict(int endpoint) {
return GetEndpoint(endpoint)->role_conflict();
}
- void SetAllocationStepDelay(int endpoint, uint32 delay) {
+ void SetAllocationStepDelay(int endpoint, uint32_t delay) {
return GetEndpoint(endpoint)->SetAllocationStepDelay(delay);
}
void SetAllowTcpListen(int endpoint, bool allow_tcp_listen) {
@@ -491,7 +491,7 @@
}
void Test(const Result& expected) {
- int32 connect_start = rtc::Time(), connect_time;
+ int32_t connect_start = rtc::Time(), connect_time;
// Create the channels and wait for them to connect.
CreateChannels(1);
@@ -515,7 +515,7 @@
// This may take up to 2 seconds.
if (ep1_ch1()->best_connection() &&
ep2_ch1()->best_connection()) {
- int32 converge_start = rtc::Time(), converge_time;
+ int32_t converge_start = rtc::Time(), converge_time;
int converge_wait = 2000;
EXPECT_TRUE_WAIT_MARGIN(CheckCandidate1(expected), converge_wait,
converge_wait);
@@ -1807,7 +1807,7 @@
ch.AddRemoteCandidate(CreateCandidate("1.1.1.1", 1, 1));
cricket::Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
ASSERT_TRUE(conn1 != nullptr);
- uint32 remote_priority = conn1->remote_candidate().priority();
+ uint32_t remote_priority = conn1->remote_candidate().priority();
// Create a higher priority candidate and make the connection
// receiving/writable. This will prune conn1.
@@ -1828,7 +1828,7 @@
request.SetType(cricket::STUN_BINDING_REQUEST);
request.AddAttribute(new cricket::StunByteStringAttribute(
cricket::STUN_ATTR_USERNAME, kIceUfrag[1]));
- uint32 prflx_priority = cricket::ICE_TYPE_PREFERENCE_PRFLX << 24;
+ uint32_t prflx_priority = cricket::ICE_TYPE_PREFERENCE_PRFLX << 24;
request.AddAttribute(new cricket::StunUInt32Attribute(
cricket::STUN_ATTR_PRIORITY, prflx_priority));
EXPECT_NE(prflx_priority, remote_priority);
@@ -1945,7 +1945,7 @@
request.SetType(cricket::STUN_BINDING_REQUEST);
request.AddAttribute(new cricket::StunByteStringAttribute(
cricket::STUN_ATTR_USERNAME, kIceUfrag[1]));
- uint32 prflx_priority = cricket::ICE_TYPE_PREFERENCE_PRFLX << 24;
+ uint32_t prflx_priority = cricket::ICE_TYPE_PREFERENCE_PRFLX << 24;
request.AddAttribute(new cricket::StunUInt32Attribute(
cricket::STUN_ATTR_PRIORITY, prflx_priority));
cricket::Port* port = GetPort(&ch);
@@ -2032,7 +2032,7 @@
request.SetType(cricket::STUN_BINDING_REQUEST);
request.AddAttribute(new cricket::StunByteStringAttribute(
cricket::STUN_ATTR_USERNAME, kIceUfrag[1]));
- uint32 prflx_priority = cricket::ICE_TYPE_PREFERENCE_PRFLX << 24;
+ uint32_t prflx_priority = cricket::ICE_TYPE_PREFERENCE_PRFLX << 24;
request.AddAttribute(new cricket::StunUInt32Attribute(
cricket::STUN_ATTR_PRIORITY, prflx_priority));
request.AddAttribute(
diff --git a/webrtc/p2p/base/packetsocketfactory.h b/webrtc/p2p/base/packetsocketfactory.h
index e51c787..5403724 100644
--- a/webrtc/p2p/base/packetsocketfactory.h
+++ b/webrtc/p2p/base/packetsocketfactory.h
@@ -30,12 +30,12 @@
virtual ~PacketSocketFactory() { }
virtual AsyncPacketSocket* CreateUdpSocket(const SocketAddress& address,
- uint16 min_port,
- uint16 max_port) = 0;
+ uint16_t min_port,
+ uint16_t max_port) = 0;
virtual AsyncPacketSocket* CreateServerTcpSocket(
const SocketAddress& local_address,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
int opts) = 0;
// TODO: |proxy_info| and |user_agent| should be set
diff --git a/webrtc/p2p/base/port.cc b/webrtc/p2p/base/port.cc
index ce28551..39fff5f 100644
--- a/webrtc/p2p/base/port.cc
+++ b/webrtc/p2p/base/port.cc
@@ -30,17 +30,16 @@
// pings fail to have a response.
inline bool TooManyFailures(
const std::vector<cricket::Connection::SentPing>& pings_since_last_response,
- uint32 maximum_failures,
- uint32 rtt_estimate,
- uint32 now) {
-
+ uint32_t maximum_failures,
+ uint32_t rtt_estimate,
+ uint32_t now) {
// If we haven't sent that many pings, then we can't have failed that many.
if (pings_since_last_response.size() < maximum_failures)
return false;
// Check if the window in which we would expect a response to the ping has
// already elapsed.
- uint32 expected_response_time =
+ uint32_t expected_response_time =
pings_since_last_response[maximum_failures - 1].sent_time + rtt_estimate;
return now > expected_response_time;
}
@@ -48,9 +47,8 @@
// Determines whether we have gone too long without seeing any response.
inline bool TooLongWithoutResponse(
const std::vector<cricket::Connection::SentPing>& pings_since_last_response,
- uint32 maximum_time,
- uint32 now) {
-
+ uint32_t maximum_time,
+ uint32_t now) {
if (pings_since_last_response.size() == 0)
return false;
@@ -60,15 +58,15 @@
// We will restrict RTT estimates (when used for determining state) to be
// within a reasonable range.
-const uint32 MINIMUM_RTT = 100; // 0.1 seconds
-const uint32 MAXIMUM_RTT = 3000; // 3 seconds
+const uint32_t MINIMUM_RTT = 100; // 0.1 seconds
+const uint32_t MAXIMUM_RTT = 3000; // 3 seconds
// When we don't have any RTT data, we have to pick something reasonable. We
// use a large value just in case the connection is really slow.
-const uint32 DEFAULT_RTT = MAXIMUM_RTT;
+const uint32_t DEFAULT_RTT = MAXIMUM_RTT;
// Computes our estimate of the RTT given the current estimate.
-inline uint32 ConservativeRTTEstimate(uint32 rtt) {
+inline uint32_t ConservativeRTTEstimate(uint32_t rtt) {
return std::max(MINIMUM_RTT, std::min(MAXIMUM_RTT, 2 * rtt));
}
@@ -128,7 +126,7 @@
const rtc::SocketAddress& base_address) {
std::ostringstream ost;
ost << type << base_address.ipaddr().ToString() << protocol;
- return rtc::ToString<uint32>(rtc::ComputeCrc32(ost.str()));
+ return rtc::ToString<uint32_t>(rtc::ComputeCrc32(ost.str()));
}
Port::Port(rtc::Thread* thread,
@@ -162,8 +160,8 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username_fragment,
const std::string& password)
: thread_(thread),
@@ -212,7 +210,7 @@
++iter;
}
- for (uint32 i = 0; i < list.size(); i++)
+ for (uint32_t i = 0; i < list.size(); i++)
delete list[i];
}
@@ -231,8 +229,8 @@
const std::string& relay_protocol,
const std::string& tcptype,
const std::string& type,
- uint32 type_preference,
- uint32 relay_preference,
+ uint32_t type_preference,
+ uint32_t relay_preference,
bool final) {
if (protocol == TCP_PROTOCOL_NAME && type == LOCAL_PORT_TYPE) {
ASSERT(!tcptype.empty());
@@ -465,7 +463,7 @@
// Validate ICE_CONTROLLING or ICE_CONTROLLED attributes.
bool ret = true;
IceRole remote_ice_role = ICEROLE_UNKNOWN;
- uint64 remote_tiebreaker = 0;
+ uint64_t remote_tiebreaker = 0;
const StunUInt64Attribute* stun_attr =
stun_msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING);
if (stun_attr) {
@@ -697,8 +695,8 @@
if (connection_->port()->send_retransmit_count_attribute()) {
request->AddAttribute(new StunUInt32Attribute(
STUN_ATTR_RETRANSMIT_COUNT,
- static_cast<uint32>(
- connection_->pings_since_last_response_.size() - 1)));
+ static_cast<uint32_t>(connection_->pings_since_last_response_.size() -
+ 1)));
}
// Adding ICE_CONTROLLED or ICE_CONTROLLING attribute based on the role.
@@ -727,7 +725,8 @@
// priority = (2^24)*(type preference) +
// (2^8)*(local preference) +
// (2^0)*(256 - component ID)
- uint32 prflx_priority = ICE_TYPE_PREFERENCE_PRFLX << 24 |
+ uint32_t prflx_priority =
+ ICE_TYPE_PREFERENCE_PRFLX << 24 |
(connection_->local_candidate().priority() & 0x00FFFFFF);
request->AddAttribute(
new StunUInt32Attribute(STUN_ATTR_PRIORITY, prflx_priority));
@@ -811,8 +810,8 @@
return port_->Candidates()[local_candidate_index_];
}
-uint64 Connection::priority() const {
- uint64 priority = 0;
+uint64_t Connection::priority() const {
+ uint64_t priority = 0;
// RFC 5245 - 5.7.2. Computing Pair Priority and Ordering Pairs
// Let G be the priority for the candidate provided by the controlling
// agent. Let D be the priority for the candidate provided by the
@@ -820,8 +819,8 @@
// pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0)
IceRole role = port_->GetIceRole();
if (role != ICEROLE_UNKNOWN) {
- uint32 g = 0;
- uint32 d = 0;
+ uint32_t g = 0;
+ uint32_t d = 0;
if (role == ICEROLE_CONTROLLING) {
g = local_candidate().priority();
d = remote_candidate_.priority();
@@ -1020,8 +1019,8 @@
*s = oss.str();
}
-void Connection::UpdateState(uint32 now) {
- uint32 rtt = ConservativeRTTEstimate(rtt_);
+void Connection::UpdateState(uint32_t now) {
+ uint32_t rtt = ConservativeRTTEstimate(rtt_);
if (LOG_CHECK_LEVEL(LS_VERBOSE)) {
std::string pings;
@@ -1052,7 +1051,7 @@
TooLongWithoutResponse(pings_since_last_response_,
CONNECTION_WRITE_CONNECT_TIMEOUT,
now)) {
- uint32 max_pings = CONNECTION_WRITE_CONNECT_FAILURES;
+ uint32_t max_pings = CONNECTION_WRITE_CONNECT_FAILURES;
LOG_J(LS_INFO, this) << "Unwritable after " << max_pings
<< " ping failures and "
<< now - pings_since_last_response_[0].sent_time
@@ -1077,7 +1076,7 @@
}
// Check the receiving state.
- uint32 last_recv_time = last_received();
+ uint32_t last_recv_time = last_received();
bool receiving = now <= last_recv_time + receiving_timeout_;
set_receiving(receiving);
if (dead(now)) {
@@ -1085,7 +1084,7 @@
}
}
-void Connection::Ping(uint32 now) {
+void Connection::Ping(uint32_t now) {
last_ping_sent_ = now;
ConnectionRequest *req = new ConnectionRequest(this);
pings_since_last_response_.push_back(SentPing(req->id(), now));
@@ -1113,7 +1112,7 @@
last_ping_response_received_ = rtc::Time();
}
-bool Connection::dead(uint32 now) const {
+bool Connection::dead(uint32_t now) const {
if (now < (time_created_ms_ + MIN_CONNECTION_LIFETIME)) {
// A connection that hasn't passed its minimum lifetime is still alive.
// We do this to prevent connections from being pruned too quickly
@@ -1198,7 +1197,7 @@
// connection.
rtc::LoggingSeverity sev = !writable() ? rtc::LS_INFO : rtc::LS_VERBOSE;
- uint32 rtt = request->Elapsed();
+ uint32_t rtt = request->Elapsed();
ReceivedPingResponse();
@@ -1299,7 +1298,7 @@
delete this;
}
-uint32 Connection::last_received() {
+uint32_t Connection::last_received() {
return std::max(last_data_received_,
std::max(last_ping_received_, last_ping_response_received_));
}
@@ -1366,7 +1365,7 @@
<< "stun response message";
return;
}
- const uint32 priority = priority_attr->value();
+ const uint32_t priority = priority_attr->value();
std::string id = rtc::CreateRandomString(8);
Candidate new_local_candidate;
diff --git a/webrtc/p2p/base/port.h b/webrtc/p2p/base/port.h
index c6b7f60..dc54876 100644
--- a/webrtc/p2p/base/port.h
+++ b/webrtc/p2p/base/port.h
@@ -52,19 +52,19 @@
// The minimum time we will wait before destroying a connection after creating
// it.
-const uint32 MIN_CONNECTION_LIFETIME = 10 * 1000; // 10 seconds.
+const uint32_t MIN_CONNECTION_LIFETIME = 10 * 1000; // 10 seconds.
// The timeout duration when a connection does not receive anything.
-const uint32 WEAK_CONNECTION_RECEIVE_TIMEOUT = 2500; // 2.5 seconds
+const uint32_t WEAK_CONNECTION_RECEIVE_TIMEOUT = 2500; // 2.5 seconds
// The length of time we wait before timing out writability on a connection.
-const uint32 CONNECTION_WRITE_TIMEOUT = 15 * 1000; // 15 seconds
+const uint32_t CONNECTION_WRITE_TIMEOUT = 15 * 1000; // 15 seconds
// The length of time we wait before we become unwritable.
-const uint32 CONNECTION_WRITE_CONNECT_TIMEOUT = 5 * 1000; // 5 seconds
+const uint32_t CONNECTION_WRITE_CONNECT_TIMEOUT = 5 * 1000; // 5 seconds
// The number of pings that must fail to respond before we become unwritable.
-const uint32 CONNECTION_WRITE_CONNECT_FAILURES = 5;
+const uint32_t CONNECTION_WRITE_CONNECT_FAILURES = 5;
// This is the length of time that we wait for a ping response to come back.
const int CONNECTION_RESPONSE_TIMEOUT = 5 * 1000; // 5 seconds
@@ -122,8 +122,8 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username_fragment,
const std::string& password);
virtual ~Port();
@@ -135,8 +135,8 @@
IceRole GetIceRole() const { return ice_role_; }
void SetIceRole(IceRole role) { ice_role_ = role; }
- void SetIceTiebreaker(uint64 tiebreaker) { tiebreaker_ = tiebreaker; }
- uint64 IceTiebreaker() const { return tiebreaker_; }
+ void SetIceTiebreaker(uint64_t tiebreaker) { tiebreaker_ = tiebreaker; }
+ uint64_t IceTiebreaker() const { return tiebreaker_; }
virtual bool SharedSocket() const { return shared_socket_; }
void ResetSharedSocket() { shared_socket_ = false; }
@@ -167,8 +167,8 @@
}
// Identifies the generation that this port was created in.
- uint32 generation() { return generation_; }
- void set_generation(uint32 generation) { generation_ = generation; }
+ uint32_t generation() { return generation_; }
+ void set_generation(uint32_t generation) { generation_ = generation; }
// ICE requires a single username/password per content/media line. So the
// |ice_username_fragment_| of the ports that belongs to the same content will
@@ -257,8 +257,8 @@
// Debugging description of this port
virtual std::string ToString() const;
const rtc::IPAddress& ip() const { return ip_; }
- uint16 min_port() { return min_port_; }
- uint16 max_port() { return max_port_; }
+ uint16_t min_port() { return min_port_; }
+ uint16_t max_port() { return max_port_; }
// Timeout shortening function to speed up unit tests.
void set_timeout_delay(int delay) { timeout_delay_ = delay; }
@@ -282,7 +282,7 @@
// Returns the index of the new local candidate.
size_t AddPrflxCandidate(const Candidate& local);
- void set_candidate_filter(uint32 candidate_filter) {
+ void set_candidate_filter(uint32_t candidate_filter) {
candidate_filter_ = candidate_filter;
}
@@ -301,8 +301,8 @@
const std::string& relay_protocol,
const std::string& tcptype,
const std::string& type,
- uint32 type_preference,
- uint32 relay_preference,
+ uint32_t type_preference,
+ uint32_t relay_preference,
bool final);
// Adds the given connection to the list. (Deleting removes them.)
@@ -333,7 +333,7 @@
return rtc::DSCP_NO_CHANGE;
}
- uint32 candidate_filter() { return candidate_filter_; }
+ uint32_t candidate_filter() { return candidate_filter_; }
private:
void Construct();
@@ -352,11 +352,11 @@
bool send_retransmit_count_attribute_;
rtc::Network* network_;
rtc::IPAddress ip_;
- uint16 min_port_;
- uint16 max_port_;
+ uint16_t min_port_;
+ uint16_t max_port_;
std::string content_name_;
int component_;
- uint32 generation_;
+ uint32_t generation_;
// In order to establish a connection to this Port (so that real data can be
// sent through), the other side must send us a STUN binding request that is
// authenticated with this username_fragment and password.
@@ -372,7 +372,7 @@
int timeout_delay_;
bool enable_port_packets_;
IceRole ice_role_;
- uint64 tiebreaker_;
+ uint64_t tiebreaker_;
bool shared_socket_;
// Information to use when going through a proxy.
std::string user_agent_;
@@ -382,7 +382,7 @@
// make its own decision on how to create candidates. For example,
// when IceTransportsType is set to relay, both RelayPort and
// TurnPort will hide raddr to avoid local address leakage.
- uint32 candidate_filter_;
+ uint32_t candidate_filter_;
friend class Connection;
};
@@ -393,12 +393,11 @@
public sigslot::has_slots<> {
public:
struct SentPing {
- SentPing(const std::string id, uint32 sent_time)
- : id(id),
- sent_time(sent_time) {}
+ SentPing(const std::string id, uint32_t sent_time)
+ : id(id), sent_time(sent_time) {}
std::string id;
- uint32 sent_time;
+ uint32_t sent_time;
};
// States are from RFC 5245. http://tools.ietf.org/html/rfc5245#section-5.7.4
@@ -422,7 +421,7 @@
const Candidate& remote_candidate() const { return remote_candidate_; }
// Returns the pair priority.
- uint64 priority() const;
+ uint64_t priority() const;
enum WriteState {
STATE_WRITABLE = 0, // we have received ping responses recently
@@ -444,10 +443,10 @@
return write_state_ != STATE_WRITE_TIMEOUT;
}
// A connection is dead if it can be safely deleted.
- bool dead(uint32 now) const;
+ bool dead(uint32_t now) const;
// Estimate of the round-trip time over this connection.
- uint32 rtt() const { return rtt_; }
+ uint32_t rtt() const { return rtt_; }
size_t sent_total_bytes();
size_t sent_bytes_second();
@@ -501,7 +500,7 @@
remote_ice_mode_ = mode;
}
- void set_receiving_timeout(uint32 receiving_timeout_ms) {
+ void set_receiving_timeout(uint32_t receiving_timeout_ms) {
receiving_timeout_ = receiving_timeout_ms;
}
@@ -510,16 +509,16 @@
// Checks that the state of this connection is up-to-date. The argument is
// the current time, which is compared against various timeouts.
- void UpdateState(uint32 now);
+ void UpdateState(uint32_t now);
// Called when this connection should try checking writability again.
- uint32 last_ping_sent() const { return last_ping_sent_; }
- void Ping(uint32 now);
+ uint32_t last_ping_sent() const { return last_ping_sent_; }
+ void Ping(uint32_t now);
void ReceivedPingResponse();
// Called whenever a valid ping is received on this connection. This is
// public because the connection intercepts the first ping for us.
- uint32 last_ping_received() const { return last_ping_received_; }
+ uint32_t last_ping_received() const { return last_ping_received_; }
void ReceivedPing();
// Debugging description of this connection
@@ -555,7 +554,7 @@
// Returns the last received time of any data, stun request, or stun
// response in milliseconds
- uint32 last_received();
+ uint32_t last_received();
protected:
enum { MSG_DELETE = 0, MSG_FIRST_AVAILABLE };
@@ -599,18 +598,18 @@
bool nominated_;
IceMode remote_ice_mode_;
StunRequestManager requests_;
- uint32 rtt_;
- uint32 last_ping_sent_; // last time we sent a ping to the other side
- uint32 last_ping_received_; // last time we received a ping from the other
- // side
- uint32 last_data_received_;
- uint32 last_ping_response_received_;
+ uint32_t rtt_;
+ uint32_t last_ping_sent_; // last time we sent a ping to the other side
+ uint32_t last_ping_received_; // last time we received a ping from the other
+ // side
+ uint32_t last_data_received_;
+ uint32_t last_ping_response_received_;
std::vector<SentPing> pings_since_last_response_;
rtc::RateTracker recv_rate_tracker_;
rtc::RateTracker send_rate_tracker_;
- uint32 sent_packets_discarded_;
- uint32 sent_packets_total_;
+ uint32_t sent_packets_discarded_;
+ uint32_t sent_packets_total_;
private:
void MaybeAddPrflxCandidate(ConnectionRequest* request,
@@ -619,8 +618,8 @@
bool reported_;
State state_;
// Time duration to switch from receiving to not receiving.
- uint32 receiving_timeout_;
- uint32 time_created_ms_;
+ uint32_t receiving_timeout_;
+ uint32_t time_created_ms_;
friend class Port;
friend class ConnectionRequest;
diff --git a/webrtc/p2p/base/port_unittest.cc b/webrtc/p2p/base/port_unittest.cc
index 4c262bc..4a4ed32 100644
--- a/webrtc/p2p/base/port_unittest.cc
+++ b/webrtc/p2p/base/port_unittest.cc
@@ -62,8 +62,9 @@
// TODO: Update these when RFC5245 is completely supported.
// Magic value of 30 is from RFC3484, for IPv4 addresses.
-static const uint32 kDefaultPrflxPriority = ICE_TYPE_PREFERENCE_PRFLX << 24 |
- 30 << 8 | (256 - ICE_CANDIDATE_COMPONENT_DEFAULT);
+static const uint32_t kDefaultPrflxPriority =
+ ICE_TYPE_PREFERENCE_PRFLX << 24 | 30 << 8 |
+ (256 - ICE_CANDIDATE_COMPONENT_DEFAULT);
static const int kTiebreaker1 = 11111;
static const int kTiebreaker2 = 22222;
@@ -100,13 +101,19 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username_fragment,
const std::string& password)
- : Port(thread, type, factory, network, ip, min_port, max_port,
- username_fragment, password) {
- }
+ : Port(thread,
+ type,
+ factory,
+ network,
+ ip,
+ min_port,
+ max_port,
+ username_fragment,
+ password) {}
~TestPort() {}
// Expose GetStunMessage so that we can test it.
@@ -249,9 +256,7 @@
void Ping() {
Ping(0);
}
- void Ping(uint32 now) {
- conn_->Ping(now);
- }
+ void Ping(uint32_t now) { conn_->Ping(now); }
void Stop() {
if (conn_) {
conn_->Destroy();
@@ -904,8 +909,8 @@
~FakePacketSocketFactory() override { }
AsyncPacketSocket* CreateUdpSocket(const SocketAddress& address,
- uint16 min_port,
- uint16 max_port) override {
+ uint16_t min_port,
+ uint16_t max_port) override {
EXPECT_TRUE(next_udp_socket_ != NULL);
AsyncPacketSocket* result = next_udp_socket_;
next_udp_socket_ = NULL;
@@ -913,8 +918,8 @@
}
AsyncPacketSocket* CreateServerTcpSocket(const SocketAddress& local_address,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
int opts) override {
EXPECT_TRUE(next_server_tcp_socket_ != NULL);
AsyncPacketSocket* result = next_server_tcp_socket_;
@@ -1967,13 +1972,13 @@
rtc::PacketTime());
ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
- uint32 last_ping_received1 = lconn->last_ping_received();
+ uint32_t last_ping_received1 = lconn->last_ping_received();
// Adding a delay of 100ms.
rtc::Thread::Current()->ProcessMessages(100);
// Pinging lconn using stun indication message.
lconn->OnReadPacket(buf->Data(), buf->Length(), rtc::PacketTime());
- uint32 last_ping_received2 = lconn->last_ping_received();
+ uint32_t last_ping_received2 = lconn->last_ping_received();
EXPECT_GT(last_ping_received2, last_ping_received1);
}
@@ -1993,15 +1998,15 @@
port->AddCandidateAddress(SocketAddress("3ffe::1234:5678", 1234));
// These should all be:
// (90 << 24) | ([rfc3484 pref value] << 8) | (256 - 177)
- uint32 expected_priority_v4 = 1509957199U;
- uint32 expected_priority_v6 = 1509959759U;
- uint32 expected_priority_ula = 1509962319U;
- uint32 expected_priority_v4mapped = expected_priority_v4;
- uint32 expected_priority_v4compat = 1509949775U;
- uint32 expected_priority_6to4 = 1509954639U;
- uint32 expected_priority_teredo = 1509952079U;
- uint32 expected_priority_sitelocal = 1509949775U;
- uint32 expected_priority_6bone = 1509949775U;
+ uint32_t expected_priority_v4 = 1509957199U;
+ uint32_t expected_priority_v6 = 1509959759U;
+ uint32_t expected_priority_ula = 1509962319U;
+ uint32_t expected_priority_v4mapped = expected_priority_v4;
+ uint32_t expected_priority_v4compat = 1509949775U;
+ uint32_t expected_priority_6to4 = 1509954639U;
+ uint32_t expected_priority_teredo = 1509952079U;
+ uint32_t expected_priority_sitelocal = 1509949775U;
+ uint32_t expected_priority_6bone = 1509949775U;
ASSERT_EQ(expected_priority_v4, port->Candidates()[0].priority());
ASSERT_EQ(expected_priority_v6, port->Candidates()[1].priority());
ASSERT_EQ(expected_priority_ula, port->Candidates()[2].priority());
@@ -2233,10 +2238,10 @@
// Ask the connection to update state as if enough time has passed to lose
// full writability and 5 pings went unresponded to. We'll accomplish the
// latter by sending pings but not pumping messages.
- for (uint32 i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
+ for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
ch1.Ping(i);
}
- uint32 unreliable_timeout_delay = CONNECTION_WRITE_CONNECT_TIMEOUT + 500u;
+ uint32_t unreliable_timeout_delay = CONNECTION_WRITE_CONNECT_TIMEOUT + 500u;
ch1.conn()->UpdateState(unreliable_timeout_delay);
EXPECT_EQ(Connection::STATE_WRITE_UNRELIABLE, ch1.conn()->write_state());
@@ -2250,7 +2255,7 @@
// Wait long enough for a full timeout (past however long we've already
// waited).
- for (uint32 i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
+ for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
ch1.Ping(unreliable_timeout_delay + i);
}
ch1.conn()->UpdateState(unreliable_timeout_delay + CONNECTION_WRITE_TIMEOUT +
@@ -2283,7 +2288,7 @@
EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state());
// Attempt to go directly to write timeout.
- for (uint32 i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
+ for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
ch1.Ping(i);
}
ch1.conn()->UpdateState(CONNECTION_WRITE_TIMEOUT + 500u);
diff --git a/webrtc/p2p/base/portallocator.cc b/webrtc/p2p/base/portallocator.cc
index b97ad55..5c4243a 100644
--- a/webrtc/p2p/base/portallocator.cc
+++ b/webrtc/p2p/base/portallocator.cc
@@ -17,7 +17,7 @@
int component,
const std::string& ice_ufrag,
const std::string& ice_pwd,
- uint32 flags)
+ uint32_t flags)
: content_name_(content_name),
component_(component),
flags_(flags),
diff --git a/webrtc/p2p/base/portallocator.h b/webrtc/p2p/base/portallocator.h
index 69b5ed0..4f8ec2f 100644
--- a/webrtc/p2p/base/portallocator.h
+++ b/webrtc/p2p/base/portallocator.h
@@ -55,12 +55,12 @@
PORTALLOCATOR_DISABLE_UDP_RELAY = 0x1000,
};
-const uint32 kDefaultPortAllocatorFlags = 0;
+const uint32_t kDefaultPortAllocatorFlags = 0;
-const uint32 kDefaultStepDelay = 1000; // 1 sec step delay.
+const uint32_t kDefaultStepDelay = 1000; // 1 sec step delay.
// As per RFC 5245 Appendix B.1, STUN transactions need to be paced at certain
// internal. Less than 20ms is not acceptable. We choose 50ms as our default.
-const uint32 kMinimumStepDelay = 50;
+const uint32_t kMinimumStepDelay = 50;
// CF = CANDIDATE FILTER
enum {
@@ -78,13 +78,13 @@
int component,
const std::string& ice_ufrag,
const std::string& ice_pwd,
- uint32 flags);
+ uint32_t flags);
// Subclasses should clean up any ports created.
virtual ~PortAllocatorSession() {}
- uint32 flags() const { return flags_; }
- void set_flags(uint32 flags) { flags_ = flags; }
+ uint32_t flags() const { return flags_; }
+ void set_flags(uint32_t flags) { flags_ = flags; }
std::string content_name() const { return content_name_; }
int component() const { return component_; }
@@ -101,8 +101,8 @@
const std::vector<Candidate>&> SignalCandidatesReady;
sigslot::signal1<PortAllocatorSession*> SignalCandidatesAllocationDone;
- virtual uint32 generation() { return generation_; }
- virtual void set_generation(uint32 generation) { generation_ = generation; }
+ virtual uint32_t generation() { return generation_; }
+ virtual void set_generation(uint32_t generation) { generation_ = generation; }
sigslot::signal1<PortAllocatorSession*> SignalDestroyed;
const std::string& ice_ufrag() const { return ice_ufrag_; }
@@ -118,8 +118,8 @@
int component_;
private:
- uint32 flags_;
- uint32 generation_;
+ uint32_t flags_;
+ uint32_t generation_;
std::string ice_ufrag_;
std::string ice_pwd_;
};
@@ -144,8 +144,8 @@
const std::string& ice_ufrag,
const std::string& ice_pwd);
- uint32 flags() const { return flags_; }
- void set_flags(uint32 flags) { flags_ = flags; }
+ uint32_t flags() const { return flags_; }
+ void set_flags(uint32_t flags) { flags_ = flags; }
const std::string& user_agent() const { return agent_; }
const rtc::ProxyInfo& proxy() const { return proxy_; }
@@ -167,18 +167,16 @@
return true;
}
- uint32 step_delay() const { return step_delay_; }
- void set_step_delay(uint32 delay) {
- step_delay_ = delay;
- }
+ uint32_t step_delay() const { return step_delay_; }
+ void set_step_delay(uint32_t delay) { step_delay_ = delay; }
bool allow_tcp_listen() const { return allow_tcp_listen_; }
void set_allow_tcp_listen(bool allow_tcp_listen) {
allow_tcp_listen_ = allow_tcp_listen;
}
- uint32 candidate_filter() { return candidate_filter_; }
- bool set_candidate_filter(uint32 filter) {
+ uint32_t candidate_filter() { return candidate_filter_; }
+ bool set_candidate_filter(uint32_t filter) {
// TODO(mallinath) - Do transition check?
candidate_filter_ = filter;
return true;
@@ -195,14 +193,14 @@
const std::string& ice_ufrag,
const std::string& ice_pwd) = 0;
- uint32 flags_;
+ uint32_t flags_;
std::string agent_;
rtc::ProxyInfo proxy_;
int min_port_;
int max_port_;
- uint32 step_delay_;
+ uint32_t step_delay_;
bool allow_tcp_listen_;
- uint32 candidate_filter_;
+ uint32_t candidate_filter_;
std::string origin_;
};
diff --git a/webrtc/p2p/base/portinterface.h b/webrtc/p2p/base/portinterface.h
index 3c246da..0c5948e 100644
--- a/webrtc/p2p/base/portinterface.h
+++ b/webrtc/p2p/base/portinterface.h
@@ -47,8 +47,8 @@
virtual void SetIceRole(IceRole role) = 0;
virtual IceRole GetIceRole() const = 0;
- virtual void SetIceTiebreaker(uint64 tiebreaker) = 0;
- virtual uint64 IceTiebreaker() const = 0;
+ virtual void SetIceTiebreaker(uint64_t tiebreaker) = 0;
+ virtual uint64_t IceTiebreaker() const = 0;
virtual bool SharedSocket() const = 0;
diff --git a/webrtc/p2p/base/pseudotcp.cc b/webrtc/p2p/base/pseudotcp.cc
index a54127b..5f035ca 100644
--- a/webrtc/p2p/base/pseudotcp.cc
+++ b/webrtc/p2p/base/pseudotcp.cc
@@ -39,40 +39,40 @@
//////////////////////////////////////////////////////////////////////
// Standard MTUs
-const uint16 PACKET_MAXIMUMS[] = {
- 65535, // Theoretical maximum, Hyperchannel
- 32000, // Nothing
- 17914, // 16Mb IBM Token Ring
- 8166, // IEEE 802.4
- //4464, // IEEE 802.5 (4Mb max)
- 4352, // FDDI
- //2048, // Wideband Network
- 2002, // IEEE 802.5 (4Mb recommended)
- //1536, // Expermental Ethernet Networks
- //1500, // Ethernet, Point-to-Point (default)
- 1492, // IEEE 802.3
- 1006, // SLIP, ARPANET
- //576, // X.25 Networks
- //544, // DEC IP Portal
- //512, // NETBIOS
- 508, // IEEE 802/Source-Rt Bridge, ARCNET
- 296, // Point-to-Point (low delay)
- //68, // Official minimum
- 0, // End of list marker
+const uint16_t PACKET_MAXIMUMS[] = {
+ 65535, // Theoretical maximum, Hyperchannel
+ 32000, // Nothing
+ 17914, // 16Mb IBM Token Ring
+ 8166, // IEEE 802.4
+ // 4464, // IEEE 802.5 (4Mb max)
+ 4352, // FDDI
+ // 2048, // Wideband Network
+ 2002, // IEEE 802.5 (4Mb recommended)
+ // 1536, // Expermental Ethernet Networks
+ // 1500, // Ethernet, Point-to-Point (default)
+ 1492, // IEEE 802.3
+ 1006, // SLIP, ARPANET
+ // 576, // X.25 Networks
+ // 544, // DEC IP Portal
+ // 512, // NETBIOS
+ 508, // IEEE 802/Source-Rt Bridge, ARCNET
+ 296, // Point-to-Point (low delay)
+ // 68, // Official minimum
+ 0, // End of list marker
};
-const uint32 MAX_PACKET = 65535;
+const uint32_t MAX_PACKET = 65535;
// Note: we removed lowest level because packet overhead was larger!
-const uint32 MIN_PACKET = 296;
+const uint32_t MIN_PACKET = 296;
-const uint32 IP_HEADER_SIZE = 20; // (+ up to 40 bytes of options?)
-const uint32 UDP_HEADER_SIZE = 8;
+const uint32_t IP_HEADER_SIZE = 20; // (+ up to 40 bytes of options?)
+const uint32_t UDP_HEADER_SIZE = 8;
// TODO: Make JINGLE_HEADER_SIZE transparent to this code?
-const uint32 JINGLE_HEADER_SIZE = 64; // when relay framing is in use
+const uint32_t JINGLE_HEADER_SIZE = 64; // when relay framing is in use
// Default size for receive and send buffer.
-const uint32 DEFAULT_RCV_BUF_SIZE = 60 * 1024;
-const uint32 DEFAULT_SND_BUF_SIZE = 90 * 1024;
+const uint32_t DEFAULT_RCV_BUF_SIZE = 60 * 1024;
+const uint32_t DEFAULT_SND_BUF_SIZE = 90 * 1024;
//////////////////////////////////////////////////////////////////////
// Global Constants and Functions
@@ -102,55 +102,59 @@
#define PSEUDO_KEEPALIVE 0
-const uint32 HEADER_SIZE = 24;
-const uint32 PACKET_OVERHEAD = HEADER_SIZE + UDP_HEADER_SIZE + IP_HEADER_SIZE + JINGLE_HEADER_SIZE;
+const uint32_t HEADER_SIZE = 24;
+const uint32_t PACKET_OVERHEAD =
+ HEADER_SIZE + UDP_HEADER_SIZE + IP_HEADER_SIZE + JINGLE_HEADER_SIZE;
-const uint32 MIN_RTO = 250; // 250 ms (RFC1122, Sec 4.2.3.1 "fractions of a second")
-const uint32 DEF_RTO = 3000; // 3 seconds (RFC1122, Sec 4.2.3.1)
-const uint32 MAX_RTO = 60000; // 60 seconds
-const uint32 DEF_ACK_DELAY = 100; // 100 milliseconds
+const uint32_t MIN_RTO =
+ 250; // 250 ms (RFC1122, Sec 4.2.3.1 "fractions of a second")
+const uint32_t DEF_RTO = 3000; // 3 seconds (RFC1122, Sec 4.2.3.1)
+const uint32_t MAX_RTO = 60000; // 60 seconds
+const uint32_t DEF_ACK_DELAY = 100; // 100 milliseconds
-const uint8 FLAG_CTL = 0x02;
-const uint8 FLAG_RST = 0x04;
+const uint8_t FLAG_CTL = 0x02;
+const uint8_t FLAG_RST = 0x04;
-const uint8 CTL_CONNECT = 0;
+const uint8_t CTL_CONNECT = 0;
// TCP options.
-const uint8 TCP_OPT_EOL = 0; // End of list.
-const uint8 TCP_OPT_NOOP = 1; // No-op.
-const uint8 TCP_OPT_MSS = 2; // Maximum segment size.
-const uint8 TCP_OPT_WND_SCALE = 3; // Window scale factor.
+const uint8_t TCP_OPT_EOL = 0; // End of list.
+const uint8_t TCP_OPT_NOOP = 1; // No-op.
+const uint8_t TCP_OPT_MSS = 2; // Maximum segment size.
+const uint8_t TCP_OPT_WND_SCALE = 3; // Window scale factor.
const long DEFAULT_TIMEOUT = 4000; // If there are no pending clocks, wake up every 4 seconds
const long CLOSED_TIMEOUT = 60 * 1000; // If the connection is closed, once per minute
#if PSEUDO_KEEPALIVE
// !?! Rethink these times
-const uint32 IDLE_PING = 20 * 1000; // 20 seconds (note: WinXP SP2 firewall udp timeout is 90 seconds)
-const uint32 IDLE_TIMEOUT = 90 * 1000; // 90 seconds;
+const uint32_t IDLE_PING =
+ 20 *
+ 1000; // 20 seconds (note: WinXP SP2 firewall udp timeout is 90 seconds)
+const uint32_t IDLE_TIMEOUT = 90 * 1000; // 90 seconds;
#endif // PSEUDO_KEEPALIVE
//////////////////////////////////////////////////////////////////////
// Helper Functions
//////////////////////////////////////////////////////////////////////
-inline void long_to_bytes(uint32 val, void* buf) {
- *static_cast<uint32*>(buf) = rtc::HostToNetwork32(val);
+inline void long_to_bytes(uint32_t val, void* buf) {
+ *static_cast<uint32_t*>(buf) = rtc::HostToNetwork32(val);
}
-inline void short_to_bytes(uint16 val, void* buf) {
- *static_cast<uint16*>(buf) = rtc::HostToNetwork16(val);
+inline void short_to_bytes(uint16_t val, void* buf) {
+ *static_cast<uint16_t*>(buf) = rtc::HostToNetwork16(val);
}
-inline uint32 bytes_to_long(const void* buf) {
- return rtc::NetworkToHost32(*static_cast<const uint32*>(buf));
+inline uint32_t bytes_to_long(const void* buf) {
+ return rtc::NetworkToHost32(*static_cast<const uint32_t*>(buf));
}
-inline uint16 bytes_to_short(const void* buf) {
- return rtc::NetworkToHost16(*static_cast<const uint16*>(buf));
+inline uint16_t bytes_to_short(const void* buf) {
+ return rtc::NetworkToHost16(*static_cast<const uint16_t*>(buf));
}
-uint32 bound(uint32 lower, uint32 middle, uint32 upper) {
+uint32_t bound(uint32_t lower, uint32_t middle, uint32_t upper) {
return std::min(std::max(lower, middle), upper);
}
@@ -196,7 +200,7 @@
// PseudoTcp
//////////////////////////////////////////////////////////////////////
-uint32 PseudoTcp::Now() {
+uint32_t PseudoTcp::Now() {
#if 0 // Use this to synchronize timers with logging timestamps (easier debug)
return rtc::TimeSince(StartTime());
#else
@@ -204,7 +208,7 @@
#endif
}
-PseudoTcp::PseudoTcp(IPseudoTcpNotify* notify, uint32 conv)
+PseudoTcp::PseudoTcp(IPseudoTcpNotify* notify, uint32_t conv)
: m_notify(notify),
m_shutdown(SD_NONE),
m_error(0),
@@ -212,11 +216,10 @@
m_rbuf(m_rbuf_len),
m_sbuf_len(DEFAULT_SND_BUF_SIZE),
m_sbuf(m_sbuf_len) {
-
// Sanity check on buffer sizes (needed for OnTcpWriteable notification logic)
ASSERT(m_rbuf_len + MIN_PACKET < m_sbuf_len);
- uint32 now = Now();
+ uint32_t now = Now();
m_state = TCP_LISTEN;
m_conv = conv;
@@ -273,14 +276,14 @@
return 0;
}
-void PseudoTcp::NotifyMTU(uint16 mtu) {
+void PseudoTcp::NotifyMTU(uint16_t mtu) {
m_mtu_advise = mtu;
if (m_state == TCP_ESTABLISHED) {
adjustMTU();
}
}
-void PseudoTcp::NotifyClock(uint32 now) {
+void PseudoTcp::NotifyClock(uint32_t now) {
if (m_state == TCP_CLOSED)
return;
@@ -303,13 +306,13 @@
return;
}
- uint32 nInFlight = m_snd_nxt - m_snd_una;
+ uint32_t nInFlight = m_snd_nxt - m_snd_una;
m_ssthresh = std::max(nInFlight / 2, 2 * m_mss);
//LOG(LS_INFO) << "m_ssthresh: " << m_ssthresh << " nInFlight: " << nInFlight << " m_mss: " << m_mss;
m_cwnd = m_mss;
// Back off retransmit timer. Note: the limit is lower when connecting.
- uint32 rto_limit = (m_state < TCP_ESTABLISHED) ? DEF_RTO : MAX_RTO;
+ uint32_t rto_limit = (m_state < TCP_ESTABLISHED) ? DEF_RTO : MAX_RTO;
m_rx_rto = std::min(rto_limit, m_rx_rto * 2);
m_rto_base = now;
}
@@ -355,10 +358,10 @@
LOG_F(WARNING) << "packet too large";
return false;
}
- return parse(reinterpret_cast<const uint8 *>(buffer), uint32(len));
+ return parse(reinterpret_cast<const uint8_t*>(buffer), uint32_t(len));
}
-bool PseudoTcp::GetNextClock(uint32 now, long& timeout) {
+bool PseudoTcp::GetNextClock(uint32_t now, long& timeout) {
return clock_check(now, timeout);
}
@@ -391,21 +394,21 @@
}
}
-uint32 PseudoTcp::GetCongestionWindow() const {
+uint32_t PseudoTcp::GetCongestionWindow() const {
return m_cwnd;
}
-uint32 PseudoTcp::GetBytesInFlight() const {
+uint32_t PseudoTcp::GetBytesInFlight() const {
return m_snd_nxt - m_snd_una;
}
-uint32 PseudoTcp::GetBytesBufferedNotSent() const {
+uint32_t PseudoTcp::GetBytesBufferedNotSent() const {
size_t buffered_bytes = 0;
m_sbuf.GetBuffered(&buffered_bytes);
- return static_cast<uint32>(m_snd_una + buffered_bytes - m_snd_nxt);
+ return static_cast<uint32_t>(m_snd_una + buffered_bytes - m_snd_nxt);
}
-uint32 PseudoTcp::GetRoundTripTimeEstimateMs() const {
+uint32_t PseudoTcp::GetRoundTripTimeEstimateMs() const {
return m_rx_srtt;
}
@@ -433,11 +436,11 @@
size_t available_space = 0;
m_rbuf.GetWriteRemaining(&available_space);
- if (uint32(available_space) - m_rcv_wnd >=
- std::min<uint32>(m_rbuf_len / 2, m_mss)) {
+ if (uint32_t(available_space) - m_rcv_wnd >=
+ std::min<uint32_t>(m_rbuf_len / 2, m_mss)) {
// TODO(jbeda): !?! Not sure about this was closed business
bool bWasClosed = (m_rcv_wnd == 0);
- m_rcv_wnd = static_cast<uint32>(available_space);
+ m_rcv_wnd = static_cast<uint32_t>(available_space);
if (bWasClosed) {
attemptSend(sfImmediateAck);
@@ -462,7 +465,7 @@
return SOCKET_ERROR;
}
- int written = queue(buffer, uint32(len), false);
+ int written = queue(buffer, uint32_t(len), false);
attemptSend();
return written;
}
@@ -480,13 +483,13 @@
// Internal Implementation
//
-uint32 PseudoTcp::queue(const char* data, uint32 len, bool bCtrl) {
+uint32_t PseudoTcp::queue(const char* data, uint32_t len, bool bCtrl) {
size_t available_space = 0;
m_sbuf.GetWriteRemaining(&available_space);
- if (len > static_cast<uint32>(available_space)) {
+ if (len > static_cast<uint32_t>(available_space)) {
ASSERT(!bCtrl);
- len = static_cast<uint32>(available_space);
+ len = static_cast<uint32_t>(available_space);
}
// We can concatenate data if the last segment is the same type
@@ -497,29 +500,31 @@
} else {
size_t snd_buffered = 0;
m_sbuf.GetBuffered(&snd_buffered);
- SSegment sseg(static_cast<uint32>(m_snd_una + snd_buffered), len, bCtrl);
+ SSegment sseg(static_cast<uint32_t>(m_snd_una + snd_buffered), len, bCtrl);
m_slist.push_back(sseg);
}
size_t written = 0;
m_sbuf.Write(data, len, &written, NULL);
- return static_cast<uint32>(written);
+ return static_cast<uint32_t>(written);
}
-IPseudoTcpNotify::WriteResult PseudoTcp::packet(uint32 seq, uint8 flags,
- uint32 offset, uint32 len) {
+IPseudoTcpNotify::WriteResult PseudoTcp::packet(uint32_t seq,
+ uint8_t flags,
+ uint32_t offset,
+ uint32_t len) {
ASSERT(HEADER_SIZE + len <= MAX_PACKET);
- uint32 now = Now();
+ uint32_t now = Now();
- rtc::scoped_ptr<uint8[]> buffer(new uint8[MAX_PACKET]);
+ rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[MAX_PACKET]);
long_to_bytes(m_conv, buffer.get());
long_to_bytes(seq, buffer.get() + 4);
long_to_bytes(m_rcv_nxt, buffer.get() + 8);
buffer[12] = 0;
buffer[13] = flags;
- short_to_bytes(
- static_cast<uint16>(m_rcv_wnd >> m_rwnd_scale), buffer.get() + 14);
+ short_to_bytes(static_cast<uint16_t>(m_rcv_wnd >> m_rwnd_scale),
+ buffer.get() + 14);
// Timestamp computations
long_to_bytes(now, buffer.get() + 16);
@@ -532,7 +537,7 @@
buffer.get() + HEADER_SIZE, len, offset, &bytes_read);
RTC_UNUSED(result);
ASSERT(result == rtc::SR_SUCCESS);
- ASSERT(static_cast<uint32>(bytes_read) == len);
+ ASSERT(static_cast<uint32_t>(bytes_read) == len);
}
#if _DEBUGMSG >= _DBG_VERBOSE
@@ -564,7 +569,7 @@
return IPseudoTcpNotify::WR_SUCCESS;
}
-bool PseudoTcp::parse(const uint8* buffer, uint32 size) {
+bool PseudoTcp::parse(const uint8_t* buffer, uint32_t size) {
if (size < 12)
return false;
@@ -595,7 +600,7 @@
return process(seg);
}
-bool PseudoTcp::clock_check(uint32 now, long& nTimeout) {
+bool PseudoTcp::clock_check(uint32_t now, long& nTimeout) {
if (m_shutdown == SD_FORCEFUL)
return false;
@@ -616,19 +621,19 @@
if (m_t_ack) {
nTimeout =
- std::min<int32>(nTimeout, rtc::TimeDiff(m_t_ack + m_ack_delay, now));
+ std::min<int32_t>(nTimeout, rtc::TimeDiff(m_t_ack + m_ack_delay, now));
}
if (m_rto_base) {
nTimeout =
- std::min<int32>(nTimeout, rtc::TimeDiff(m_rto_base + m_rx_rto, now));
+ std::min<int32_t>(nTimeout, rtc::TimeDiff(m_rto_base + m_rx_rto, now));
}
if (m_snd_wnd == 0) {
nTimeout =
- std::min<int32>(nTimeout, rtc::TimeDiff(m_lastsend + m_rx_rto, now));
+ std::min<int32_t>(nTimeout, rtc::TimeDiff(m_lastsend + m_rx_rto, now));
}
#if PSEUDO_KEEPALIVE
if (m_state == TCP_ESTABLISHED) {
- nTimeout = std::min<int32>(
+ nTimeout = std::min<int32_t>(
nTimeout, rtc::TimeDiff(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3 / 2
: IDLE_PING),
now));
@@ -647,7 +652,7 @@
return false;
}
- uint32 now = Now();
+ uint32_t now = Now();
m_lasttraffic = m_lastrecv = now;
m_bOutgoing = false;
@@ -704,20 +709,22 @@
if ((seg.ack > m_snd_una) && (seg.ack <= m_snd_nxt)) {
// Calculate round-trip time
if (seg.tsecr) {
- int32 rtt = rtc::TimeDiff(now, seg.tsecr);
+ int32_t rtt = rtc::TimeDiff(now, seg.tsecr);
if (rtt >= 0) {
if (m_rx_srtt == 0) {
m_rx_srtt = rtt;
m_rx_rttvar = rtt / 2;
} else {
- uint32 unsigned_rtt = static_cast<uint32>(rtt);
- uint32 abs_err = unsigned_rtt > m_rx_srtt ? unsigned_rtt - m_rx_srtt
- : m_rx_srtt - unsigned_rtt;
+ uint32_t unsigned_rtt = static_cast<uint32_t>(rtt);
+ uint32_t abs_err = unsigned_rtt > m_rx_srtt
+ ? unsigned_rtt - m_rx_srtt
+ : m_rx_srtt - unsigned_rtt;
m_rx_rttvar = (3 * m_rx_rttvar + abs_err) / 4;
m_rx_srtt = (7 * m_rx_srtt + rtt) / 8;
}
- m_rx_rto = bound(
- MIN_RTO, m_rx_srtt + std::max<uint32>(1, 4 * m_rx_rttvar), MAX_RTO);
+ m_rx_rto =
+ bound(MIN_RTO, m_rx_srtt + std::max<uint32_t>(1, 4 * m_rx_rttvar),
+ MAX_RTO);
#if _DEBUGMSG >= _DBG_VERBOSE
LOG(LS_INFO) << "rtt: " << rtt
<< " srtt: " << m_rx_srtt
@@ -728,16 +735,16 @@
}
}
- m_snd_wnd = static_cast<uint32>(seg.wnd) << m_swnd_scale;
+ m_snd_wnd = static_cast<uint32_t>(seg.wnd) << m_swnd_scale;
- uint32 nAcked = seg.ack - m_snd_una;
+ uint32_t nAcked = seg.ack - m_snd_una;
m_snd_una = seg.ack;
m_rto_base = (m_snd_una == m_snd_nxt) ? 0 : now;
m_sbuf.ConsumeReadData(nAcked);
- for (uint32 nFree = nAcked; nFree > 0; ) {
+ for (uint32_t nFree = nAcked; nFree > 0;) {
ASSERT(!m_slist.empty());
if (nFree < m_slist.front().len) {
m_slist.front().len -= nFree;
@@ -753,7 +760,7 @@
if (m_dup_acks >= 3) {
if (m_snd_una >= m_recover) { // NewReno
- uint32 nInFlight = m_snd_nxt - m_snd_una;
+ uint32_t nInFlight = m_snd_nxt - m_snd_una;
m_cwnd = std::min(m_ssthresh, nInFlight + m_mss); // (Fast Retransmit)
#if _DEBUGMSG >= _DBG_NORMAL
LOG(LS_INFO) << "exit recovery";
@@ -775,12 +782,12 @@
if (m_cwnd < m_ssthresh) {
m_cwnd += m_mss;
} else {
- m_cwnd += std::max<uint32>(1, m_mss * m_mss / m_cwnd);
+ m_cwnd += std::max<uint32_t>(1, m_mss * m_mss / m_cwnd);
}
}
} else if (seg.ack == m_snd_una) {
// !?! Note, tcp says don't do this... but otherwise how does a closed window become open?
- m_snd_wnd = static_cast<uint32>(seg.wnd) << m_swnd_scale;
+ m_snd_wnd = static_cast<uint32_t>(seg.wnd) << m_swnd_scale;
// Check duplicate acks
if (seg.len > 0) {
@@ -797,7 +804,7 @@
return false;
}
m_recover = m_snd_nxt;
- uint32 nInFlight = m_snd_nxt - m_snd_una;
+ uint32_t nInFlight = m_snd_nxt - m_snd_una;
m_ssthresh = std::max(nInFlight / 2, 2 * m_mss);
//LOG(LS_INFO) << "m_ssthresh: " << m_ssthresh << " nInFlight: " << nInFlight << " m_mss: " << m_mss;
m_cwnd = m_ssthresh + 3 * m_mss;
@@ -823,10 +830,11 @@
// If we make room in the send queue, notify the user
// The goal it to make sure we always have at least enough data to fill the
// window. We'd like to notify the app when we are halfway to that point.
- const uint32 kIdealRefillSize = (m_sbuf_len + m_rbuf_len) / 2;
+ const uint32_t kIdealRefillSize = (m_sbuf_len + m_rbuf_len) / 2;
size_t snd_buffered = 0;
m_sbuf.GetBuffered(&snd_buffered);
- if (m_bWriteEnable && static_cast<uint32>(snd_buffered) < kIdealRefillSize) {
+ if (m_bWriteEnable &&
+ static_cast<uint32_t>(snd_buffered) < kIdealRefillSize) {
m_bWriteEnable = false;
if (m_notify) {
m_notify->OnTcpWriteable(this);
@@ -862,7 +870,7 @@
// Adjust the incoming segment to fit our receive buffer
if (seg.seq < m_rcv_nxt) {
- uint32 nAdjust = m_rcv_nxt - seg.seq;
+ uint32_t nAdjust = m_rcv_nxt - seg.seq;
if (nAdjust < seg.len) {
seg.seq += nAdjust;
seg.data += nAdjust;
@@ -875,8 +883,10 @@
size_t available_space = 0;
m_rbuf.GetWriteRemaining(&available_space);
- if ((seg.seq + seg.len - m_rcv_nxt) > static_cast<uint32>(available_space)) {
- uint32 nAdjust = seg.seq + seg.len - m_rcv_nxt - static_cast<uint32>(available_space);
+ if ((seg.seq + seg.len - m_rcv_nxt) >
+ static_cast<uint32_t>(available_space)) {
+ uint32_t nAdjust =
+ seg.seq + seg.len - m_rcv_nxt - static_cast<uint32_t>(available_space);
if (nAdjust < seg.len) {
seg.len -= nAdjust;
} else {
@@ -893,7 +903,7 @@
m_rcv_nxt += seg.len;
}
} else {
- uint32 nOffset = seg.seq - m_rcv_nxt;
+ uint32_t nOffset = seg.seq - m_rcv_nxt;
rtc::StreamResult result = m_rbuf.WriteOffset(seg.data, seg.len,
nOffset, NULL);
@@ -910,7 +920,7 @@
while ((it != m_rlist.end()) && (it->seq <= m_rcv_nxt)) {
if (it->seq + it->len > m_rcv_nxt) {
sflags = sfImmediateAck; // (Fast Recovery)
- uint32 nAdjust = (it->seq + it->len) - m_rcv_nxt;
+ uint32_t nAdjust = (it->seq + it->len) - m_rcv_nxt;
#if _DEBUGMSG >= _DBG_NORMAL
LOG(LS_INFO) << "Recovered " << nAdjust << " bytes (" << m_rcv_nxt << " -> " << m_rcv_nxt + nAdjust << ")";
#endif // _DEBUGMSG
@@ -950,17 +960,17 @@
return true;
}
-bool PseudoTcp::transmit(const SList::iterator& seg, uint32 now) {
+bool PseudoTcp::transmit(const SList::iterator& seg, uint32_t now) {
if (seg->xmit >= ((m_state == TCP_ESTABLISHED) ? 15 : 30)) {
LOG_F(LS_VERBOSE) << "too many retransmits";
return false;
}
- uint32 nTransmit = std::min(seg->len, m_mss);
+ uint32_t nTransmit = std::min(seg->len, m_mss);
while (true) {
- uint32 seq = seg->seq;
- uint8 flags = (seg->bCtrl ? FLAG_CTL : 0);
+ uint32_t seq = seg->seq;
+ uint8_t flags = (seg->bCtrl ? FLAG_CTL : 0);
IPseudoTcpNotify::WriteResult wres = packet(seq,
flags,
seg->seq - m_snd_una,
@@ -1020,7 +1030,7 @@
}
void PseudoTcp::attemptSend(SendFlags sflags) {
- uint32 now = Now();
+ uint32_t now = Now();
if (rtc::TimeDiff(now, m_lastsend) > static_cast<long>(m_rx_rto)) {
m_cwnd = m_mss;
@@ -1032,18 +1042,18 @@
#endif // _DEBUGMSG
while (true) {
- uint32 cwnd = m_cwnd;
+ uint32_t cwnd = m_cwnd;
if ((m_dup_acks == 1) || (m_dup_acks == 2)) { // Limited Transmit
cwnd += m_dup_acks * m_mss;
}
- uint32 nWindow = std::min(m_snd_wnd, cwnd);
- uint32 nInFlight = m_snd_nxt - m_snd_una;
- uint32 nUseable = (nInFlight < nWindow) ? (nWindow - nInFlight) : 0;
+ uint32_t nWindow = std::min(m_snd_wnd, cwnd);
+ uint32_t nInFlight = m_snd_nxt - m_snd_una;
+ uint32_t nUseable = (nInFlight < nWindow) ? (nWindow - nInFlight) : 0;
size_t snd_buffered = 0;
m_sbuf.GetBuffered(&snd_buffered);
- uint32 nAvailable =
- std::min(static_cast<uint32>(snd_buffered) - nInFlight, m_mss);
+ uint32_t nAvailable =
+ std::min(static_cast<uint32_t>(snd_buffered) - nInFlight, m_mss);
if (nAvailable > nUseable) {
if (nUseable * 4 < nWindow) {
@@ -1116,8 +1126,7 @@
}
}
-void
-PseudoTcp::closedown(uint32 err) {
+void PseudoTcp::closedown(uint32_t err) {
LOG(LS_INFO) << "State: TCP_CLOSED";
m_state = TCP_CLOSED;
if (m_notify) {
@@ -1130,7 +1139,7 @@
PseudoTcp::adjustMTU() {
// Determine our current mss level, so that we can adjust appropriately later
for (m_msslevel = 0; PACKET_MAXIMUMS[m_msslevel + 1] > 0; ++m_msslevel) {
- if (static_cast<uint16>(PACKET_MAXIMUMS[m_msslevel]) <= m_mtu_advise) {
+ if (static_cast<uint16_t>(PACKET_MAXIMUMS[m_msslevel]) <= m_mtu_advise) {
break;
}
}
@@ -1166,19 +1175,18 @@
buf.WriteUInt8(1);
buf.WriteUInt8(m_rwnd_scale);
}
- m_snd_wnd = static_cast<uint32>(buf.Length());
- queue(buf.Data(), static_cast<uint32>(buf.Length()), true);
+ m_snd_wnd = static_cast<uint32_t>(buf.Length());
+ queue(buf.Data(), static_cast<uint32_t>(buf.Length()), true);
}
-void
-PseudoTcp::parseOptions(const char* data, uint32 len) {
- std::set<uint8> options_specified;
+void PseudoTcp::parseOptions(const char* data, uint32_t len) {
+ std::set<uint8_t> options_specified;
// See http://www.freesoft.org/CIE/Course/Section4/8.htm for
// parsing the options list.
rtc::ByteBuffer buf(data, len);
while (buf.Length()) {
- uint8 kind = TCP_OPT_EOL;
+ uint8_t kind = TCP_OPT_EOL;
buf.ReadUInt8(&kind);
if (kind == TCP_OPT_EOL) {
@@ -1192,7 +1200,7 @@
// Length of this option.
ASSERT(len != 0);
RTC_UNUSED(len);
- uint8 opt_len = 0;
+ uint8_t opt_len = 0;
buf.ReadUInt8(&opt_len);
// Content of this option.
@@ -1218,8 +1226,7 @@
}
}
-void
-PseudoTcp::applyOption(char kind, const char* data, uint32 len) {
+void PseudoTcp::applyOption(char kind, const char* data, uint32_t len) {
if (kind == TCP_OPT_MSS) {
LOG(LS_WARNING) << "Peer specified MSS option which is not supported.";
// TODO: Implement.
@@ -1234,20 +1241,17 @@
}
}
-void
-PseudoTcp::applyWindowScaleOption(uint8 scale_factor) {
+void PseudoTcp::applyWindowScaleOption(uint8_t scale_factor) {
m_swnd_scale = scale_factor;
}
-void
-PseudoTcp::resizeSendBuffer(uint32 new_size) {
+void PseudoTcp::resizeSendBuffer(uint32_t new_size) {
m_sbuf_len = new_size;
m_sbuf.SetCapacity(new_size);
}
-void
-PseudoTcp::resizeReceiveBuffer(uint32 new_size) {
- uint8 scale_factor = 0;
+void PseudoTcp::resizeReceiveBuffer(uint32_t new_size) {
+ uint8_t scale_factor = 0;
// Determine the scale factor such that the scaled window size can fit
// in a 16-bit unsigned integer.
@@ -1272,7 +1276,7 @@
size_t available_space = 0;
m_rbuf.GetWriteRemaining(&available_space);
- m_rcv_wnd = static_cast<uint32>(available_space);
+ m_rcv_wnd = static_cast<uint32_t>(available_space);
}
} // namespace cricket
diff --git a/webrtc/p2p/base/pseudotcp.h b/webrtc/p2p/base/pseudotcp.h
index b2cfcb7..6d402da 100644
--- a/webrtc/p2p/base/pseudotcp.h
+++ b/webrtc/p2p/base/pseudotcp.h
@@ -30,7 +30,7 @@
virtual void OnTcpOpen(PseudoTcp* tcp) = 0;
virtual void OnTcpReadable(PseudoTcp* tcp) = 0;
virtual void OnTcpWriteable(PseudoTcp* tcp) = 0;
- virtual void OnTcpClosed(PseudoTcp* tcp, uint32 error) = 0;
+ virtual void OnTcpClosed(PseudoTcp* tcp, uint32_t error) = 0;
// Write the packet onto the network
enum WriteResult { WR_SUCCESS, WR_TOO_LARGE, WR_FAIL };
@@ -47,9 +47,9 @@
class PseudoTcp {
public:
- static uint32 Now();
+ static uint32_t Now();
- PseudoTcp(IPseudoTcpNotify* notify, uint32 conv);
+ PseudoTcp(IPseudoTcpNotify* notify, uint32_t conv);
virtual ~PseudoTcp();
int Connect();
@@ -64,11 +64,11 @@
TcpState State() const { return m_state; }
// Call this when the PMTU changes.
- void NotifyMTU(uint16 mtu);
+ void NotifyMTU(uint16_t mtu);
// Call this based on timeout value returned from GetNextClock.
// It's ok to call this too frequently.
- void NotifyClock(uint32 now);
+ void NotifyClock(uint32_t now);
// Call this whenever a packet arrives.
// Returns true if the packet was processed successfully.
@@ -76,7 +76,7 @@
// Call this to determine the next time NotifyClock should be called.
// Returns false if the socket is ready to be destroyed.
- bool GetNextClock(uint32 now, long& timeout);
+ bool GetNextClock(uint32_t now, long& timeout);
// Call these to get/set option values to tailor this PseudoTcp
// instance's behaviour for the kind of data it will carry.
@@ -94,47 +94,46 @@
void SetOption(Option opt, int value);
// Returns current congestion window in bytes.
- uint32 GetCongestionWindow() const;
+ uint32_t GetCongestionWindow() const;
// Returns amount of data in bytes that has been sent, but haven't
// been acknowledged.
- uint32 GetBytesInFlight() const;
+ uint32_t GetBytesInFlight() const;
// Returns number of bytes that were written in buffer and haven't
// been sent.
- uint32 GetBytesBufferedNotSent() const;
+ uint32_t GetBytesBufferedNotSent() const;
// Returns current round-trip time estimate in milliseconds.
- uint32 GetRoundTripTimeEstimateMs() const;
+ uint32_t GetRoundTripTimeEstimateMs() const;
protected:
enum SendFlags { sfNone, sfDelayedAck, sfImmediateAck };
struct Segment {
- uint32 conv, seq, ack;
- uint8 flags;
- uint16 wnd;
+ uint32_t conv, seq, ack;
+ uint8_t flags;
+ uint16_t wnd;
const char * data;
- uint32 len;
- uint32 tsval, tsecr;
+ uint32_t len;
+ uint32_t tsval, tsecr;
};
struct SSegment {
- SSegment(uint32 s, uint32 l, bool c)
- : seq(s), len(l), /*tstamp(0),*/ xmit(0), bCtrl(c) {
- }
- uint32 seq, len;
- //uint32 tstamp;
- uint8 xmit;
+ SSegment(uint32_t s, uint32_t l, bool c)
+ : seq(s), len(l), /*tstamp(0),*/ xmit(0), bCtrl(c) {}
+ uint32_t seq, len;
+ // uint32_t tstamp;
+ uint8_t xmit;
bool bCtrl;
};
typedef std::list<SSegment> SList;
struct RSegment {
- uint32 seq, len;
+ uint32_t seq, len;
};
- uint32 queue(const char* data, uint32 len, bool bCtrl);
+ uint32_t queue(const char* data, uint32_t len, bool bCtrl);
// Creates a packet and submits it to the network. This method can either
// send payload or just an ACK packet.
@@ -144,18 +143,20 @@
// |offset| is the offset to read from |m_sbuf|.
// |len| is the number of bytes to read from |m_sbuf| as payload. If this
// value is 0 then this is an ACK packet, otherwise this packet has payload.
- IPseudoTcpNotify::WriteResult packet(uint32 seq, uint8 flags,
- uint32 offset, uint32 len);
- bool parse(const uint8* buffer, uint32 size);
+ IPseudoTcpNotify::WriteResult packet(uint32_t seq,
+ uint8_t flags,
+ uint32_t offset,
+ uint32_t len);
+ bool parse(const uint8_t* buffer, uint32_t size);
void attemptSend(SendFlags sflags = sfNone);
- void closedown(uint32 err = 0);
+ void closedown(uint32_t err = 0);
- bool clock_check(uint32 now, long& nTimeout);
+ bool clock_check(uint32_t now, long& nTimeout);
bool process(Segment& seg);
- bool transmit(const SList::iterator& seg, uint32 now);
+ bool transmit(const SList::iterator& seg, uint32_t now);
void adjustMTU();
@@ -172,20 +173,20 @@
void queueConnectMessage();
// Parse TCP options in the header.
- void parseOptions(const char* data, uint32 len);
+ void parseOptions(const char* data, uint32_t len);
// Apply a TCP option that has been read from the header.
- void applyOption(char kind, const char* data, uint32 len);
+ void applyOption(char kind, const char* data, uint32_t len);
// Apply window scale option.
- void applyWindowScaleOption(uint8 scale_factor);
+ void applyWindowScaleOption(uint8_t scale_factor);
// Resize the send buffer with |new_size| in bytes.
- void resizeSendBuffer(uint32 new_size);
+ void resizeSendBuffer(uint32_t new_size);
// Resize the receive buffer with |new_size| in bytes. This call adjusts
// window scale factor |m_swnd_scale| accordingly.
- void resizeReceiveBuffer(uint32 new_size);
+ void resizeReceiveBuffer(uint32_t new_size);
IPseudoTcpNotify* m_notify;
enum Shutdown { SD_NONE, SD_GRACEFUL, SD_FORCEFUL } m_shutdown;
@@ -193,43 +194,43 @@
// TCB data
TcpState m_state;
- uint32 m_conv;
+ uint32_t m_conv;
bool m_bReadEnable, m_bWriteEnable, m_bOutgoing;
- uint32 m_lasttraffic;
+ uint32_t m_lasttraffic;
// Incoming data
typedef std::list<RSegment> RList;
RList m_rlist;
- uint32 m_rbuf_len, m_rcv_nxt, m_rcv_wnd, m_lastrecv;
- uint8 m_rwnd_scale; // Window scale factor.
+ uint32_t m_rbuf_len, m_rcv_nxt, m_rcv_wnd, m_lastrecv;
+ uint8_t m_rwnd_scale; // Window scale factor.
rtc::FifoBuffer m_rbuf;
// Outgoing data
SList m_slist;
- uint32 m_sbuf_len, m_snd_nxt, m_snd_wnd, m_lastsend, m_snd_una;
- uint8 m_swnd_scale; // Window scale factor.
+ uint32_t m_sbuf_len, m_snd_nxt, m_snd_wnd, m_lastsend, m_snd_una;
+ uint8_t m_swnd_scale; // Window scale factor.
rtc::FifoBuffer m_sbuf;
// Maximum segment size, estimated protocol level, largest segment sent
- uint32 m_mss, m_msslevel, m_largest, m_mtu_advise;
+ uint32_t m_mss, m_msslevel, m_largest, m_mtu_advise;
// Retransmit timer
- uint32 m_rto_base;
+ uint32_t m_rto_base;
// Timestamp tracking
- uint32 m_ts_recent, m_ts_lastack;
+ uint32_t m_ts_recent, m_ts_lastack;
// Round-trip calculation
- uint32 m_rx_rttvar, m_rx_srtt, m_rx_rto;
+ uint32_t m_rx_rttvar, m_rx_srtt, m_rx_rto;
// Congestion avoidance, Fast retransmit/recovery, Delayed ACKs
- uint32 m_ssthresh, m_cwnd;
- uint8 m_dup_acks;
- uint32 m_recover;
- uint32 m_t_ack;
+ uint32_t m_ssthresh, m_cwnd;
+ uint8_t m_dup_acks;
+ uint32_t m_recover;
+ uint32_t m_t_ack;
// Configuration options
bool m_use_nagling;
- uint32 m_ack_delay;
+ uint32_t m_ack_delay;
// This is used by unit tests to test backward compatibility of
// PseudoTcp implementations that don't support window scaling.
diff --git a/webrtc/p2p/base/pseudotcp_unittest.cc b/webrtc/p2p/base/pseudotcp_unittest.cc
index 03e7293..c9ccbca 100644
--- a/webrtc/p2p/base/pseudotcp_unittest.cc
+++ b/webrtc/p2p/base/pseudotcp_unittest.cc
@@ -27,9 +27,8 @@
class PseudoTcpForTest : public cricket::PseudoTcp {
public:
- PseudoTcpForTest(cricket::IPseudoTcpNotify* notify, uint32 conv)
- : PseudoTcp(notify, conv) {
- }
+ PseudoTcpForTest(cricket::IPseudoTcpNotify* notify, uint32_t conv)
+ : PseudoTcp(notify, conv) {}
bool isReceiveBufferFull() const {
return PseudoTcp::isReceiveBufferFull();
@@ -127,7 +126,7 @@
// virtual void OnTcpReadable(PseudoTcp* tcp)
// and
// virtual void OnTcpWritable(PseudoTcp* tcp)
- virtual void OnTcpClosed(PseudoTcp* tcp, uint32 error) {
+ virtual void OnTcpClosed(PseudoTcp* tcp, uint32_t error) {
// Consider ourselves closed when the remote side gets OnTcpClosed.
// TODO: OnTcpClosed is only ever notified in case of error in
// the current implementation. Solicited close is not (yet) supported.
@@ -141,7 +140,7 @@
const char* buffer, size_t len) {
// Randomly drop the desired percentage of packets.
// Also drop packets that are larger than the configured MTU.
- if (rtc::CreateRandomId() % 100 < static_cast<uint32>(loss_)) {
+ if (rtc::CreateRandomId() % 100 < static_cast<uint32_t>(loss_)) {
LOG(LS_VERBOSE) << "Randomly dropping packet, size=" << len;
} else if (len > static_cast<size_t>(std::min(local_mtu_, remote_mtu_))) {
LOG(LS_VERBOSE) << "Dropping packet that exceeds path MTU, size=" << len;
@@ -156,7 +155,7 @@
void UpdateLocalClock() { UpdateClock(&local_, MSG_LCLOCK); }
void UpdateRemoteClock() { UpdateClock(&remote_, MSG_RCLOCK); }
- void UpdateClock(PseudoTcp* tcp, uint32 message) {
+ void UpdateClock(PseudoTcp* tcp, uint32_t message) {
long interval = 0; // NOLINT
tcp->GetNextClock(PseudoTcp::Now(), interval);
interval = std::max<int>(interval, 0L); // sometimes interval is < 0
@@ -209,7 +208,7 @@
class PseudoTcpTest : public PseudoTcpTestBase {
public:
void TestTransfer(int size) {
- uint32 start, elapsed;
+ uint32_t start, elapsed;
size_t received;
// Create some dummy data to send.
send_stream_.ReserveSize(size);
@@ -326,7 +325,7 @@
bytes_per_send_ = bytes;
}
void TestPingPong(int size, int iterations) {
- uint32 start, elapsed;
+ uint32_t start, elapsed;
iterations_remaining_ = iterations;
receiver_ = &remote_;
sender_ = &local_;
@@ -489,12 +488,12 @@
}
}
- uint32 EstimateReceiveWindowSize() const {
- return static_cast<uint32>(recv_position_[0]);
+ uint32_t EstimateReceiveWindowSize() const {
+ return static_cast<uint32_t>(recv_position_[0]);
}
- uint32 EstimateSendWindowSize() const {
- return static_cast<uint32>(send_position_[0] - recv_position_[0]);
+ uint32_t EstimateSendWindowSize() const {
+ return static_cast<uint32_t>(send_position_[0] - recv_position_[0]);
}
private:
diff --git a/webrtc/p2p/base/relayport.cc b/webrtc/p2p/base/relayport.cc
index fc077ff..ccddab0 100644
--- a/webrtc/p2p/base/relayport.cc
+++ b/webrtc/p2p/base/relayport.cc
@@ -16,7 +16,7 @@
namespace cricket {
-static const uint32 kMessageConnectTimeout = 1;
+static const uint32_t kMessageConnectTimeout = 1;
static const int kKeepAliveDelay = 10 * 60 * 1000;
static const int kRetryTimeout = 50 * 1000; // ICE says 50 secs
// How long to wait for a socket to connect to remote host in milliseconds
@@ -171,19 +171,26 @@
private:
RelayEntry* entry_;
RelayConnection* connection_;
- uint32 start_time_;
+ uint32_t start_time_;
};
RelayPort::RelayPort(rtc::Thread* thread,
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password)
- : Port(thread, RELAY_PORT_TYPE, factory, network, ip, min_port, max_port,
- username, password),
+ : Port(thread,
+ RELAY_PORT_TYPE,
+ factory,
+ network,
+ ip,
+ min_port,
+ max_port,
+ username,
+ password),
ready_(false),
error_(0) {
entries_.push_back(
diff --git a/webrtc/p2p/base/relayport.h b/webrtc/p2p/base/relayport.h
index 6297142..8452b5b 100644
--- a/webrtc/p2p/base/relayport.h
+++ b/webrtc/p2p/base/relayport.h
@@ -35,15 +35,14 @@
typedef std::pair<rtc::Socket::Option, int> OptionValue;
// RelayPort doesn't yet do anything fancy in the ctor.
- static RelayPort* Create(
- rtc::Thread* thread,
- rtc::PacketSocketFactory* factory,
- rtc::Network* network,
- const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
- const std::string& username,
- const std::string& password) {
+ static RelayPort* Create(rtc::Thread* thread,
+ rtc::PacketSocketFactory* factory,
+ rtc::Network* network,
+ const rtc::IPAddress& ip,
+ uint16_t min_port,
+ uint16_t max_port,
+ const std::string& username,
+ const std::string& password) {
return new RelayPort(thread, factory, network, ip, min_port, max_port,
username, password);
}
@@ -74,8 +73,8 @@
rtc::PacketSocketFactory* factory,
rtc::Network*,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password);
bool Init();
diff --git a/webrtc/p2p/base/relayserver.cc b/webrtc/p2p/base/relayserver.cc
index 19e9268..e208d70 100644
--- a/webrtc/p2p/base/relayserver.cc
+++ b/webrtc/p2p/base/relayserver.cc
@@ -27,7 +27,7 @@
const int MAX_LIFETIME = 15 * 60 * 1000;
// The number of bytes in each of the usernames we use.
-const uint32 USERNAME_LENGTH = 16;
+const uint32_t USERNAME_LENGTH = 16;
// Calls SendTo on the given socket and logs any bad results.
void Send(rtc::AsyncPacketSocket* socket, const char* bytes, size_t size,
@@ -263,8 +263,8 @@
return;
}
- uint32 length =
- std::min(static_cast<uint32>(username_attr->length()), USERNAME_LENGTH);
+ uint32_t length =
+ std::min(static_cast<uint32_t>(username_attr->length()), USERNAME_LENGTH);
std::string username(username_attr->bytes(), length);
// TODO: Check the HMAC.
@@ -355,7 +355,7 @@
// else-branch will then disappear.
// Compute the appropriate lifetime for this binding.
- uint32 lifetime = MAX_LIFETIME;
+ uint32_t lifetime = MAX_LIFETIME;
const StunUInt32Attribute* lifetime_attr =
request.GetUInt32(STUN_ATTR_LIFETIME);
if (lifetime_attr)
@@ -530,7 +530,7 @@
void RelayServer::OnMessage(rtc::Message *pmsg) {
#if ENABLE_DEBUG
- static const uint32 kMessageAcceptConnection = 1;
+ static const uint32_t kMessageAcceptConnection = 1;
ASSERT(pmsg->message_id == kMessageAcceptConnection);
#endif
rtc::MessageData* data = pmsg->pdata;
@@ -616,7 +616,7 @@
StunByteStringAttribute* data_attr =
StunAttribute::CreateByteString(STUN_ATTR_DATA);
ASSERT(size <= 65536);
- data_attr->CopyBytes(data, uint16(size));
+ data_attr->CopyBytes(data, uint16_t(size));
msg.AddAttribute(data_attr);
SendStun(msg);
@@ -648,13 +648,16 @@
}
// IDs used for posted messages:
-const uint32 MSG_LIFETIME_TIMER = 1;
+const uint32_t MSG_LIFETIME_TIMER = 1;
-RelayServerBinding::RelayServerBinding(
- RelayServer* server, const std::string& username,
- const std::string& password, uint32 lifetime)
- : server_(server), username_(username), password_(password),
- lifetime_(lifetime) {
+RelayServerBinding::RelayServerBinding(RelayServer* server,
+ const std::string& username,
+ const std::string& password,
+ uint32_t lifetime)
+ : server_(server),
+ username_(username),
+ password_(password),
+ lifetime_(lifetime) {
// For now, every connection uses the standard magic cookie value.
magic_cookie_.append(
reinterpret_cast<const char*>(TURN_MAGIC_COOKIE_VALUE),
diff --git a/webrtc/p2p/base/relayserver.h b/webrtc/p2p/base/relayserver.h
index e0e45d5..f1109f1 100644
--- a/webrtc/p2p/base/relayserver.h
+++ b/webrtc/p2p/base/relayserver.h
@@ -181,13 +181,14 @@
// or in other words, that are "bound" together.
class RelayServerBinding : public rtc::MessageHandler {
public:
- RelayServerBinding(
- RelayServer* server, const std::string& username,
- const std::string& password, uint32 lifetime);
+ RelayServerBinding(RelayServer* server,
+ const std::string& username,
+ const std::string& password,
+ uint32_t lifetime);
virtual ~RelayServerBinding();
RelayServer* server() { return server_; }
- uint32 lifetime() { return lifetime_; }
+ uint32_t lifetime() { return lifetime_; }
const std::string& username() { return username_; }
const std::string& password() { return password_; }
const std::string& magic_cookie() { return magic_cookie_; }
@@ -225,8 +226,8 @@
std::vector<RelayServerConnection*> internal_connections_;
std::vector<RelayServerConnection*> external_connections_;
- uint32 lifetime_;
- uint32 last_used_;
+ uint32_t lifetime_;
+ uint32_t last_used_;
// TODO: bandwidth
};
diff --git a/webrtc/p2p/base/relayserver_unittest.cc b/webrtc/p2p/base/relayserver_unittest.cc
index 4f1164a..83e5353 100644
--- a/webrtc/p2p/base/relayserver_unittest.cc
+++ b/webrtc/p2p/base/relayserver_unittest.cc
@@ -24,7 +24,7 @@
using rtc::SocketAddress;
using namespace cricket;
-static const uint32 LIFETIME = 4; // seconds
+static const uint32_t LIFETIME = 4; // seconds
static const SocketAddress server_int_addr("127.0.0.1", 5000);
static const SocketAddress server_ext_addr("127.0.0.1", 5001);
static const SocketAddress client1_addr("127.0.0.1", 6000 + (rand() % 1000));
diff --git a/webrtc/p2p/base/stun.cc b/webrtc/p2p/base/stun.cc
index 866621f..9c22995 100644
--- a/webrtc/p2p/base/stun.cc
+++ b/webrtc/p2p/base/stun.cc
@@ -38,7 +38,7 @@
const char TURN_MAGIC_COOKIE_VALUE[] = { '\x72', '\xC6', '\x4B', '\xC6' };
const char EMPTY_TRANSACTION_ID[] = "0000000000000000";
-const uint32 STUN_FINGERPRINT_XOR_VALUE = 0x5354554E;
+const uint32_t STUN_FINGERPRINT_XOR_VALUE = 0x5354554E;
// StunMessage
@@ -82,7 +82,7 @@
if (attr_length % 4 != 0) {
attr_length += (4 - (attr_length % 4));
}
- length_ += static_cast<uint16>(attr_length + 4);
+ length_ += static_cast<uint16_t>(attr_length + 4);
return true;
}
@@ -135,7 +135,7 @@
}
// Getting the message length from the STUN header.
- uint16 msg_length = rtc::GetBE16(&data[2]);
+ uint16_t msg_length = rtc::GetBE16(&data[2]);
if (size != (msg_length + kStunHeaderSize)) {
return false;
}
@@ -144,7 +144,7 @@
size_t current_pos = kStunHeaderSize;
bool has_message_integrity_attr = false;
while (current_pos < size) {
- uint16 attr_type, attr_length;
+ uint16_t attr_type, attr_length;
// Getting attribute type and length.
attr_type = rtc::GetBE16(&data[current_pos]);
attr_length = rtc::GetBE16(&data[current_pos + sizeof(attr_type)]);
@@ -187,8 +187,7 @@
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |0 0| STUN Message Type | Message Length |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
- rtc::SetBE16(temp_data.get() + 2,
- static_cast<uint16>(new_adjusted_len));
+ rtc::SetBE16(temp_data.get() + 2, static_cast<uint16_t>(new_adjusted_len));
}
char hmac[kStunMessageIntegritySize];
@@ -262,12 +261,12 @@
// Check the fingerprint type and length.
const char* fingerprint_attr_data = data + size - fingerprint_attr_size;
if (rtc::GetBE16(fingerprint_attr_data) != STUN_ATTR_FINGERPRINT ||
- rtc::GetBE16(fingerprint_attr_data + sizeof(uint16)) !=
+ rtc::GetBE16(fingerprint_attr_data + sizeof(uint16_t)) !=
StunUInt32Attribute::SIZE)
return false;
// Check the fingerprint value.
- uint32 fingerprint =
+ uint32_t fingerprint =
rtc::GetBE32(fingerprint_attr_data + kStunAttributeHeaderSize);
return ((fingerprint ^ STUN_FINGERPRINT_XOR_VALUE) ==
rtc::ComputeCrc32(data, size - fingerprint_attr_size));
@@ -287,7 +286,7 @@
int msg_len_for_crc32 = static_cast<int>(
buf.Length() - kStunAttributeHeaderSize - fingerprint_attr->length());
- uint32 c = rtc::ComputeCrc32(buf.Data(), msg_len_for_crc32);
+ uint32_t c = rtc::ComputeCrc32(buf.Data(), msg_len_for_crc32);
// Insert the correct CRC-32, XORed with a constant, into the attribute.
fingerprint_attr->SetValue(c ^ STUN_FINGERPRINT_XOR_VALUE);
@@ -315,8 +314,8 @@
if (!buf->ReadString(&transaction_id, kStunTransactionIdLength))
return false;
- uint32 magic_cookie_int =
- *reinterpret_cast<const uint32*>(magic_cookie.data());
+ uint32_t magic_cookie_int =
+ *reinterpret_cast<const uint32_t*>(magic_cookie.data());
if (rtc::NetworkToHost32(magic_cookie_int) != kStunMagicCookie) {
// If magic cookie is invalid it means that the peer implements
// RFC3489 instead of RFC5389.
@@ -332,7 +331,7 @@
size_t rest = buf->Length() - length_;
while (buf->Length() > rest) {
- uint16 attr_type, attr_length;
+ uint16_t attr_type, attr_length;
if (!buf->ReadUInt16(&attr_type))
return false;
if (!buf->ReadUInt16(&attr_length))
@@ -366,7 +365,7 @@
for (size_t i = 0; i < attrs_->size(); ++i) {
buf->WriteUInt16((*attrs_)[i]->type());
- buf->WriteUInt16(static_cast<uint16>((*attrs_)[i]->length()));
+ buf->WriteUInt16(static_cast<uint16_t>((*attrs_)[i]->length()));
if (!(*attrs_)[i]->Write(buf))
return false;
}
@@ -395,8 +394,8 @@
StunAttribute* StunMessage::CreateAttribute(int type, size_t length) /*const*/ {
StunAttributeValueType value_type = GetAttributeValueType(type);
- return StunAttribute::Create(value_type, type,
- static_cast<uint16>(length), this);
+ return StunAttribute::Create(value_type, type, static_cast<uint16_t>(length),
+ this);
}
const StunAttribute* StunMessage::GetAttribute(int type) const {
@@ -414,7 +413,7 @@
// StunAttribute
-StunAttribute::StunAttribute(uint16 type, uint16 length)
+StunAttribute::StunAttribute(uint16_t type, uint16_t length)
: type_(type), length_(length) {
}
@@ -434,7 +433,8 @@
}
StunAttribute* StunAttribute::Create(StunAttributeValueType value_type,
- uint16 type, uint16 length,
+ uint16_t type,
+ uint16_t length,
StunMessage* owner) {
switch (value_type) {
case STUN_VALUE_ADDRESS:
@@ -456,23 +456,23 @@
}
}
-StunAddressAttribute* StunAttribute::CreateAddress(uint16 type) {
+StunAddressAttribute* StunAttribute::CreateAddress(uint16_t type) {
return new StunAddressAttribute(type, 0);
}
-StunXorAddressAttribute* StunAttribute::CreateXorAddress(uint16 type) {
+StunXorAddressAttribute* StunAttribute::CreateXorAddress(uint16_t type) {
return new StunXorAddressAttribute(type, 0, NULL);
}
-StunUInt64Attribute* StunAttribute::CreateUInt64(uint16 type) {
+StunUInt64Attribute* StunAttribute::CreateUInt64(uint16_t type) {
return new StunUInt64Attribute(type);
}
-StunUInt32Attribute* StunAttribute::CreateUInt32(uint16 type) {
+StunUInt32Attribute* StunAttribute::CreateUInt32(uint16_t type) {
return new StunUInt32Attribute(type);
}
-StunByteStringAttribute* StunAttribute::CreateByteString(uint16 type) {
+StunByteStringAttribute* StunAttribute::CreateByteString(uint16_t type) {
return new StunByteStringAttribute(type, 0);
}
@@ -485,26 +485,26 @@
return new StunUInt16ListAttribute(STUN_ATTR_UNKNOWN_ATTRIBUTES, 0);
}
-StunAddressAttribute::StunAddressAttribute(uint16 type,
- const rtc::SocketAddress& addr)
- : StunAttribute(type, 0) {
+StunAddressAttribute::StunAddressAttribute(uint16_t type,
+ const rtc::SocketAddress& addr)
+ : StunAttribute(type, 0) {
SetAddress(addr);
}
-StunAddressAttribute::StunAddressAttribute(uint16 type, uint16 length)
+StunAddressAttribute::StunAddressAttribute(uint16_t type, uint16_t length)
: StunAttribute(type, length) {
}
bool StunAddressAttribute::Read(ByteBuffer* buf) {
- uint8 dummy;
+ uint8_t dummy;
if (!buf->ReadUInt8(&dummy))
return false;
- uint8 stun_family;
+ uint8_t stun_family;
if (!buf->ReadUInt8(&stun_family)) {
return false;
}
- uint16 port;
+ uint16_t port;
if (!buf->ReadUInt16(&port))
return false;
if (stun_family == STUN_ADDRESS_IPV4) {
@@ -557,15 +557,16 @@
return true;
}
-StunXorAddressAttribute::StunXorAddressAttribute(uint16 type,
- const rtc::SocketAddress& addr)
+StunXorAddressAttribute::StunXorAddressAttribute(uint16_t type,
+ const rtc::SocketAddress& addr)
: StunAddressAttribute(type, addr), owner_(NULL) {
}
-StunXorAddressAttribute::StunXorAddressAttribute(uint16 type,
- uint16 length,
+StunXorAddressAttribute::StunXorAddressAttribute(uint16_t type,
+ uint16_t length,
StunMessage* owner)
- : StunAddressAttribute(type, length), owner_(owner) {}
+ : StunAddressAttribute(type, length), owner_(owner) {
+}
rtc::IPAddress StunXorAddressAttribute::GetXoredIP() const {
if (owner_) {
@@ -581,10 +582,10 @@
in6_addr v6addr = ip.ipv6_address();
const std::string& transaction_id = owner_->transaction_id();
if (transaction_id.length() == kStunTransactionIdLength) {
- uint32 transactionid_as_ints[3];
+ uint32_t transactionid_as_ints[3];
memcpy(&transactionid_as_ints[0], transaction_id.c_str(),
transaction_id.length());
- uint32* ip_as_ints = reinterpret_cast<uint32*>(&v6addr.s6_addr);
+ uint32_t* ip_as_ints = reinterpret_cast<uint32_t*>(&v6addr.s6_addr);
// Transaction ID is in network byte order, but magic cookie
// is stored in host byte order.
ip_as_ints[0] =
@@ -606,7 +607,7 @@
bool StunXorAddressAttribute::Read(ByteBuffer* buf) {
if (!StunAddressAttribute::Read(buf))
return false;
- uint16 xoredport = port() ^ (kStunMagicCookie >> 16);
+ uint16_t xoredport = port() ^ (kStunMagicCookie >> 16);
rtc::IPAddress xored_ip = GetXoredIP();
SetAddress(rtc::SocketAddress(xored_ip, xoredport));
return true;
@@ -640,11 +641,11 @@
return true;
}
-StunUInt32Attribute::StunUInt32Attribute(uint16 type, uint32 value)
+StunUInt32Attribute::StunUInt32Attribute(uint16_t type, uint32_t value)
: StunAttribute(type, SIZE), bits_(value) {
}
-StunUInt32Attribute::StunUInt32Attribute(uint16 type)
+StunUInt32Attribute::StunUInt32Attribute(uint16_t type)
: StunAttribute(type, SIZE), bits_(0) {
}
@@ -670,11 +671,11 @@
return true;
}
-StunUInt64Attribute::StunUInt64Attribute(uint16 type, uint64 value)
+StunUInt64Attribute::StunUInt64Attribute(uint16_t type, uint64_t value)
: StunAttribute(type, SIZE), bits_(value) {
}
-StunUInt64Attribute::StunUInt64Attribute(uint16 type)
+StunUInt64Attribute::StunUInt64Attribute(uint16_t type)
: StunAttribute(type, SIZE), bits_(0) {
}
@@ -689,24 +690,24 @@
return true;
}
-StunByteStringAttribute::StunByteStringAttribute(uint16 type)
+StunByteStringAttribute::StunByteStringAttribute(uint16_t type)
: StunAttribute(type, 0), bytes_(NULL) {
}
-StunByteStringAttribute::StunByteStringAttribute(uint16 type,
+StunByteStringAttribute::StunByteStringAttribute(uint16_t type,
const std::string& str)
: StunAttribute(type, 0), bytes_(NULL) {
CopyBytes(str.c_str(), str.size());
}
-StunByteStringAttribute::StunByteStringAttribute(uint16 type,
+StunByteStringAttribute::StunByteStringAttribute(uint16_t type,
const void* bytes,
size_t length)
: StunAttribute(type, 0), bytes_(NULL) {
CopyBytes(bytes, length);
}
-StunByteStringAttribute::StunByteStringAttribute(uint16 type, uint16 length)
+StunByteStringAttribute::StunByteStringAttribute(uint16_t type, uint16_t length)
: StunAttribute(type, length), bytes_(NULL) {
}
@@ -724,13 +725,13 @@
SetBytes(new_bytes, length);
}
-uint8 StunByteStringAttribute::GetByte(size_t index) const {
+uint8_t StunByteStringAttribute::GetByte(size_t index) const {
ASSERT(bytes_ != NULL);
ASSERT(index < length());
- return static_cast<uint8>(bytes_[index]);
+ return static_cast<uint8_t>(bytes_[index]);
}
-void StunByteStringAttribute::SetByte(size_t index, uint8 value) {
+void StunByteStringAttribute::SetByte(size_t index, uint8_t value) {
ASSERT(bytes_ != NULL);
ASSERT(index < length());
bytes_[index] = value;
@@ -755,17 +756,18 @@
void StunByteStringAttribute::SetBytes(char* bytes, size_t length) {
delete [] bytes_;
bytes_ = bytes;
- SetLength(static_cast<uint16>(length));
+ SetLength(static_cast<uint16_t>(length));
}
-StunErrorCodeAttribute::StunErrorCodeAttribute(uint16 type, int code,
+StunErrorCodeAttribute::StunErrorCodeAttribute(uint16_t type,
+ int code,
const std::string& reason)
: StunAttribute(type, 0) {
SetCode(code);
SetReason(reason);
}
-StunErrorCodeAttribute::StunErrorCodeAttribute(uint16 type, uint16 length)
+StunErrorCodeAttribute::StunErrorCodeAttribute(uint16_t type, uint16_t length)
: StunAttribute(type, length), class_(0), number_(0) {
}
@@ -777,17 +779,17 @@
}
void StunErrorCodeAttribute::SetCode(int code) {
- class_ = static_cast<uint8>(code / 100);
- number_ = static_cast<uint8>(code % 100);
+ class_ = static_cast<uint8_t>(code / 100);
+ number_ = static_cast<uint8_t>(code % 100);
}
void StunErrorCodeAttribute::SetReason(const std::string& reason) {
- SetLength(MIN_SIZE + static_cast<uint16>(reason.size()));
+ SetLength(MIN_SIZE + static_cast<uint16_t>(reason.size()));
reason_ = reason;
}
bool StunErrorCodeAttribute::Read(ByteBuffer* buf) {
- uint32 val;
+ uint32_t val;
if (length() < MIN_SIZE || !buf->ReadUInt32(&val))
return false;
@@ -811,9 +813,9 @@
return true;
}
-StunUInt16ListAttribute::StunUInt16ListAttribute(uint16 type, uint16 length)
+StunUInt16ListAttribute::StunUInt16ListAttribute(uint16_t type, uint16_t length)
: StunAttribute(type, length) {
- attr_types_ = new std::vector<uint16>();
+ attr_types_ = new std::vector<uint16_t>();
}
StunUInt16ListAttribute::~StunUInt16ListAttribute() {
@@ -824,17 +826,17 @@
return attr_types_->size();
}
-uint16 StunUInt16ListAttribute::GetType(int index) const {
+uint16_t StunUInt16ListAttribute::GetType(int index) const {
return (*attr_types_)[index];
}
-void StunUInt16ListAttribute::SetType(int index, uint16 value) {
+void StunUInt16ListAttribute::SetType(int index, uint16_t value) {
(*attr_types_)[index] = value;
}
-void StunUInt16ListAttribute::AddType(uint16 value) {
+void StunUInt16ListAttribute::AddType(uint16_t value) {
attr_types_->push_back(value);
- SetLength(static_cast<uint16>(attr_types_->size() * 2));
+ SetLength(static_cast<uint16_t>(attr_types_->size() * 2));
}
bool StunUInt16ListAttribute::Read(ByteBuffer* buf) {
@@ -842,7 +844,7 @@
return false;
for (size_t i = 0; i < length() / 2; i++) {
- uint16 attr;
+ uint16_t attr;
if (!buf->ReadUInt16(&attr))
return false;
attr_types_->push_back(attr);
diff --git a/webrtc/p2p/base/stun.h b/webrtc/p2p/base/stun.h
index 4bf6547..75b89af 100644
--- a/webrtc/p2p/base/stun.h
+++ b/webrtc/p2p/base/stun.h
@@ -97,7 +97,7 @@
extern const char STUN_ERROR_REASON_SERVER_ERROR[];
// The mask used to determine whether a STUN message is a request/response etc.
-const uint32 kStunTypeMask = 0x0110;
+const uint32_t kStunTypeMask = 0x0110;
// STUN Attribute header length.
const size_t kStunAttributeHeaderSize = 4;
@@ -106,7 +106,7 @@
const size_t kStunHeaderSize = 20;
const size_t kStunTransactionIdOffset = 8;
const size_t kStunTransactionIdLength = 12;
-const uint32 kStunMagicCookie = 0x2112A442;
+const uint32_t kStunMagicCookie = 0x2112A442;
const size_t kStunMagicCookieLength = sizeof(kStunMagicCookie);
// Following value corresponds to an earlier version of STUN from
@@ -145,7 +145,7 @@
// is determined by the lengths of the transaction ID.
bool IsLegacy() const;
- void SetType(int type) { type_ = static_cast<uint16>(type); }
+ void SetType(int type) { type_ = static_cast<uint16_t>(type); }
bool SetTransactionID(const std::string& str);
// Gets the desired attribute value, or NULL if no such attribute type exists.
@@ -198,8 +198,8 @@
const StunAttribute* GetAttribute(int type) const;
static bool IsValidTransactionId(const std::string& transaction_id);
- uint16 type_;
- uint16 length_;
+ uint16_t type_;
+ uint16_t length_;
std::string transaction_id_;
std::vector<StunAttribute*>* attrs_;
};
@@ -228,37 +228,39 @@
virtual bool Write(rtc::ByteBuffer* buf) const = 0;
// Creates an attribute object with the given type and smallest length.
- static StunAttribute* Create(StunAttributeValueType value_type, uint16 type,
- uint16 length, StunMessage* owner);
+ static StunAttribute* Create(StunAttributeValueType value_type,
+ uint16_t type,
+ uint16_t length,
+ StunMessage* owner);
// TODO: Allow these create functions to take parameters, to reduce
// the amount of work callers need to do to initialize attributes.
- static StunAddressAttribute* CreateAddress(uint16 type);
- static StunXorAddressAttribute* CreateXorAddress(uint16 type);
- static StunUInt32Attribute* CreateUInt32(uint16 type);
- static StunUInt64Attribute* CreateUInt64(uint16 type);
- static StunByteStringAttribute* CreateByteString(uint16 type);
+ static StunAddressAttribute* CreateAddress(uint16_t type);
+ static StunXorAddressAttribute* CreateXorAddress(uint16_t type);
+ static StunUInt32Attribute* CreateUInt32(uint16_t type);
+ static StunUInt64Attribute* CreateUInt64(uint16_t type);
+ static StunByteStringAttribute* CreateByteString(uint16_t type);
static StunErrorCodeAttribute* CreateErrorCode();
static StunUInt16ListAttribute* CreateUnknownAttributes();
protected:
- StunAttribute(uint16 type, uint16 length);
- void SetLength(uint16 length) { length_ = length; }
+ StunAttribute(uint16_t type, uint16_t length);
+ void SetLength(uint16_t length) { length_ = length; }
void WritePadding(rtc::ByteBuffer* buf) const;
void ConsumePadding(rtc::ByteBuffer* buf) const;
private:
- uint16 type_;
- uint16 length_;
+ uint16_t type_;
+ uint16_t length_;
};
// Implements STUN attributes that record an Internet address.
class StunAddressAttribute : public StunAttribute {
public:
- static const uint16 SIZE_UNDEF = 0;
- static const uint16 SIZE_IP4 = 8;
- static const uint16 SIZE_IP6 = 20;
- StunAddressAttribute(uint16 type, const rtc::SocketAddress& addr);
- StunAddressAttribute(uint16 type, uint16 length);
+ static const uint16_t SIZE_UNDEF = 0;
+ static const uint16_t SIZE_IP4 = 8;
+ static const uint16_t SIZE_IP6 = 20;
+ StunAddressAttribute(uint16_t type, const rtc::SocketAddress& addr);
+ StunAddressAttribute(uint16_t type, uint16_t length);
virtual StunAttributeValueType value_type() const {
return STUN_VALUE_ADDRESS;
@@ -276,7 +278,7 @@
const rtc::SocketAddress& GetAddress() const { return address_; }
const rtc::IPAddress& ipaddr() const { return address_.ipaddr(); }
- uint16 port() const { return address_.port(); }
+ uint16_t port() const { return address_.port(); }
void SetAddress(const rtc::SocketAddress& addr) {
address_ = addr;
@@ -286,7 +288,7 @@
address_.SetIP(ip);
EnsureAddressLength();
}
- void SetPort(uint16 port) { address_.SetPort(port); }
+ void SetPort(uint16_t port) { address_.SetPort(port); }
virtual bool Read(rtc::ByteBuffer* buf);
virtual bool Write(rtc::ByteBuffer* buf) const;
@@ -316,9 +318,8 @@
// transaction ID of the message.
class StunXorAddressAttribute : public StunAddressAttribute {
public:
- StunXorAddressAttribute(uint16 type, const rtc::SocketAddress& addr);
- StunXorAddressAttribute(uint16 type, uint16 length,
- StunMessage* owner);
+ StunXorAddressAttribute(uint16_t type, const rtc::SocketAddress& addr);
+ StunXorAddressAttribute(uint16_t type, uint16_t length, StunMessage* owner);
virtual StunAttributeValueType value_type() const {
return STUN_VALUE_XOR_ADDRESS;
@@ -337,16 +338,16 @@
// Implements STUN attributes that record a 32-bit integer.
class StunUInt32Attribute : public StunAttribute {
public:
- static const uint16 SIZE = 4;
- StunUInt32Attribute(uint16 type, uint32 value);
- explicit StunUInt32Attribute(uint16 type);
+ static const uint16_t SIZE = 4;
+ StunUInt32Attribute(uint16_t type, uint32_t value);
+ explicit StunUInt32Attribute(uint16_t type);
virtual StunAttributeValueType value_type() const {
return STUN_VALUE_UINT32;
}
- uint32 value() const { return bits_; }
- void SetValue(uint32 bits) { bits_ = bits; }
+ uint32_t value() const { return bits_; }
+ void SetValue(uint32_t bits) { bits_ = bits; }
bool GetBit(size_t index) const;
void SetBit(size_t index, bool value);
@@ -355,36 +356,36 @@
virtual bool Write(rtc::ByteBuffer* buf) const;
private:
- uint32 bits_;
+ uint32_t bits_;
};
class StunUInt64Attribute : public StunAttribute {
public:
- static const uint16 SIZE = 8;
- StunUInt64Attribute(uint16 type, uint64 value);
- explicit StunUInt64Attribute(uint16 type);
+ static const uint16_t SIZE = 8;
+ StunUInt64Attribute(uint16_t type, uint64_t value);
+ explicit StunUInt64Attribute(uint16_t type);
virtual StunAttributeValueType value_type() const {
return STUN_VALUE_UINT64;
}
- uint64 value() const { return bits_; }
- void SetValue(uint64 bits) { bits_ = bits; }
+ uint64_t value() const { return bits_; }
+ void SetValue(uint64_t bits) { bits_ = bits; }
virtual bool Read(rtc::ByteBuffer* buf);
virtual bool Write(rtc::ByteBuffer* buf) const;
private:
- uint64 bits_;
+ uint64_t bits_;
};
// Implements STUN attributes that record an arbitrary byte string.
class StunByteStringAttribute : public StunAttribute {
public:
- explicit StunByteStringAttribute(uint16 type);
- StunByteStringAttribute(uint16 type, const std::string& str);
- StunByteStringAttribute(uint16 type, const void* bytes, size_t length);
- StunByteStringAttribute(uint16 type, uint16 length);
+ explicit StunByteStringAttribute(uint16_t type);
+ StunByteStringAttribute(uint16_t type, const std::string& str);
+ StunByteStringAttribute(uint16_t type, const void* bytes, size_t length);
+ StunByteStringAttribute(uint16_t type, uint16_t length);
~StunByteStringAttribute();
virtual StunAttributeValueType value_type() const {
@@ -397,8 +398,8 @@
void CopyBytes(const char* bytes); // uses strlen
void CopyBytes(const void* bytes, size_t length);
- uint8 GetByte(size_t index) const;
- void SetByte(size_t index, uint8 value);
+ uint8_t GetByte(size_t index) const;
+ void SetByte(size_t index, uint8_t value);
virtual bool Read(rtc::ByteBuffer* buf);
virtual bool Write(rtc::ByteBuffer* buf) const;
@@ -412,9 +413,9 @@
// Implements STUN attributes that record an error code.
class StunErrorCodeAttribute : public StunAttribute {
public:
- static const uint16 MIN_SIZE = 4;
- StunErrorCodeAttribute(uint16 type, int code, const std::string& reason);
- StunErrorCodeAttribute(uint16 type, uint16 length);
+ static const uint16_t MIN_SIZE = 4;
+ StunErrorCodeAttribute(uint16_t type, int code, const std::string& reason);
+ StunErrorCodeAttribute(uint16_t type, uint16_t length);
~StunErrorCodeAttribute();
virtual StunAttributeValueType value_type() const {
@@ -429,23 +430,23 @@
int eclass() const { return class_; }
int number() const { return number_; }
const std::string& reason() const { return reason_; }
- void SetClass(uint8 eclass) { class_ = eclass; }
- void SetNumber(uint8 number) { number_ = number; }
+ void SetClass(uint8_t eclass) { class_ = eclass; }
+ void SetNumber(uint8_t number) { number_ = number; }
void SetReason(const std::string& reason);
bool Read(rtc::ByteBuffer* buf);
bool Write(rtc::ByteBuffer* buf) const;
private:
- uint8 class_;
- uint8 number_;
+ uint8_t class_;
+ uint8_t number_;
std::string reason_;
};
// Implements STUN attributes that record a list of attribute names.
class StunUInt16ListAttribute : public StunAttribute {
public:
- StunUInt16ListAttribute(uint16 type, uint16 length);
+ StunUInt16ListAttribute(uint16_t type, uint16_t length);
~StunUInt16ListAttribute();
virtual StunAttributeValueType value_type() const {
@@ -453,15 +454,15 @@
}
size_t Size() const;
- uint16 GetType(int index) const;
- void SetType(int index, uint16 value);
- void AddType(uint16 value);
+ uint16_t GetType(int index) const;
+ void SetType(int index, uint16_t value);
+ void AddType(uint16_t value);
bool Read(rtc::ByteBuffer* buf);
bool Write(rtc::ByteBuffer* buf) const;
private:
- std::vector<uint16>* attr_types_;
+ std::vector<uint16_t>* attr_types_;
};
// Returns the (successful) response type for the given request type.
diff --git a/webrtc/p2p/base/stun_unittest.cc b/webrtc/p2p/base/stun_unittest.cc
index 9d5779d7..cd4f7e1 100644
--- a/webrtc/p2p/base/stun_unittest.cc
+++ b/webrtc/p2p/base/stun_unittest.cc
@@ -165,7 +165,7 @@
0x61, 0x62, 0x63, 0xcc // abc
};
-// Message with an Unknown Attributes (uint16 list) attribute.
+// Message with an Unknown Attributes (uint16_t list) attribute.
static const unsigned char kStunMessageWithUInt16ListAttribute[] = {
0x00, 0x01, 0x00, 0x0c,
0x21, 0x12, 0xa4, 0x42,
diff --git a/webrtc/p2p/base/stunport.cc b/webrtc/p2p/base/stunport.cc
index 696d323..615bbfe 100644
--- a/webrtc/p2p/base/stunport.cc
+++ b/webrtc/p2p/base/stunport.cc
@@ -106,7 +106,7 @@
UDPPort* port_;
bool keep_alive_;
const rtc::SocketAddress server_addr_;
- uint32 start_time_;
+ uint32_t start_time_;
};
UDPPort::AddressResolver::AddressResolver(
@@ -182,14 +182,21 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password,
const std::string& origin,
bool emit_localhost_for_anyaddress)
- : Port(thread, LOCAL_PORT_TYPE, factory, network, ip, min_port, max_port,
- username, password),
+ : Port(thread,
+ LOCAL_PORT_TYPE,
+ factory,
+ network,
+ ip,
+ min_port,
+ max_port,
+ username,
+ password),
requests_(thread),
socket_(NULL),
error_(0),
diff --git a/webrtc/p2p/base/stunport.h b/webrtc/p2p/base/stunport.h
index 2967c15..488739c 100644
--- a/webrtc/p2p/base/stunport.h
+++ b/webrtc/p2p/base/stunport.h
@@ -50,8 +50,8 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password,
const std::string& origin,
@@ -110,8 +110,8 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password,
const std::string& origin,
@@ -220,7 +220,8 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port, uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password,
const ServerAddresses& servers,
@@ -247,14 +248,22 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password,
const ServerAddresses& servers,
const std::string& origin)
- : UDPPort(thread, factory, network, ip, min_port, max_port, username,
- password, origin, false) {
+ : UDPPort(thread,
+ factory,
+ network,
+ ip,
+ min_port,
+ max_port,
+ username,
+ password,
+ origin,
+ false) {
// UDPPort will set these to local udp, updating these to STUN.
set_type(STUN_PORT_TYPE);
set_server_addresses(servers);
diff --git a/webrtc/p2p/base/stunport_unittest.cc b/webrtc/p2p/base/stunport_unittest.cc
index 173bcae..037d448 100644
--- a/webrtc/p2p/base/stunport_unittest.cc
+++ b/webrtc/p2p/base/stunport_unittest.cc
@@ -30,7 +30,7 @@
static const SocketAddress kBadHostnameAddr("not-a-real-hostname", 5000);
static const int kTimeoutMs = 10000;
// stun prio = 100 << 24 | 30 (IPV4) << 8 | 256 - 0
-static const uint32 kStunCandidatePriority = 1677729535;
+static const uint32_t kStunCandidatePriority = 1677729535;
// Tests connecting a StunPort to a fake STUN server (cricket::StunServer)
// TODO: Use a VirtualSocketServer here. We have to use a
diff --git a/webrtc/p2p/base/stunrequest.cc b/webrtc/p2p/base/stunrequest.cc
index c5700c0..df5614d 100644
--- a/webrtc/p2p/base/stunrequest.cc
+++ b/webrtc/p2p/base/stunrequest.cc
@@ -18,7 +18,7 @@
namespace cricket {
-const uint32 MSG_STUN_SEND = 1;
+const uint32_t MSG_STUN_SEND = 1;
const int MAX_SENDS = 9;
const int DELAY_UNIT = 100; // 100 milliseconds
@@ -68,7 +68,7 @@
for (RequestMap::iterator i = requests_.begin(); i != requests_.end(); ++i)
requests.push_back(i->second);
- for (uint32 i = 0; i < requests.size(); ++i) {
+ for (uint32_t i = 0; i < requests.size(); ++i) {
// StunRequest destructor calls Remove() which deletes requests
// from |requests_|.
delete requests[i];
@@ -171,7 +171,7 @@
return msg_;
}
-uint32 StunRequest::Elapsed() const {
+uint32_t StunRequest::Elapsed() const {
return rtc::TimeSince(tstamp_);
}
diff --git a/webrtc/p2p/base/stunrequest.h b/webrtc/p2p/base/stunrequest.h
index e6b9e7d..267b4a1 100644
--- a/webrtc/p2p/base/stunrequest.h
+++ b/webrtc/p2p/base/stunrequest.h
@@ -90,7 +90,7 @@
const StunMessage* msg() const;
// Time elapsed since last send (in ms)
- uint32 Elapsed() const;
+ uint32_t Elapsed() const;
protected:
int count_;
@@ -118,7 +118,7 @@
StunRequestManager* manager_;
StunMessage* msg_;
- uint32 tstamp_;
+ uint32_t tstamp_;
friend class StunRequestManager;
};
diff --git a/webrtc/p2p/base/stunrequest_unittest.cc b/webrtc/p2p/base/stunrequest_unittest.cc
index 3ff6cba..8a23834 100644
--- a/webrtc/p2p/base/stunrequest_unittest.cc
+++ b/webrtc/p2p/base/stunrequest_unittest.cc
@@ -146,13 +146,13 @@
TEST_F(StunRequestTest, TestBackoff) {
StunMessage* req = CreateStunMessage(STUN_BINDING_REQUEST, NULL);
- uint32 start = rtc::Time();
+ uint32_t start = rtc::Time();
manager_.Send(new StunRequestThunker(req, this));
StunMessage* res = CreateStunMessage(STUN_BINDING_RESPONSE, req);
for (int i = 0; i < 9; ++i) {
while (request_count_ == i)
rtc::Thread::Current()->ProcessMessages(1);
- int32 elapsed = rtc::TimeSince(start);
+ int32_t elapsed = rtc::TimeSince(start);
LOG(LS_INFO) << "STUN request #" << (i + 1)
<< " sent at " << elapsed << " ms";
EXPECT_GE(TotalDelay(i + 1), elapsed);
diff --git a/webrtc/p2p/base/tcpport.cc b/webrtc/p2p/base/tcpport.cc
index 86982b0..2590d0a 100644
--- a/webrtc/p2p/base/tcpport.cc
+++ b/webrtc/p2p/base/tcpport.cc
@@ -76,13 +76,20 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password,
bool allow_listen)
- : Port(thread, LOCAL_PORT_TYPE, factory, network, ip, min_port, max_port,
- username, password),
+ : Port(thread,
+ LOCAL_PORT_TYPE,
+ factory,
+ network,
+ ip,
+ min_port,
+ max_port,
+ username,
+ password),
incoming_only_(false),
allow_listen_(allow_listen),
socket_(NULL),
diff --git a/webrtc/p2p/base/tcpport.h b/webrtc/p2p/base/tcpport.h
index d86f750..a64c5ee 100644
--- a/webrtc/p2p/base/tcpport.h
+++ b/webrtc/p2p/base/tcpport.h
@@ -32,8 +32,8 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password,
bool allow_listen) {
@@ -61,8 +61,8 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password,
bool allow_listen);
diff --git a/webrtc/p2p/base/transport.h b/webrtc/p2p/base/transport.h
index 6324cd6..dfd512f 100644
--- a/webrtc/p2p/base/transport.h
+++ b/webrtc/p2p/base/transport.h
@@ -160,8 +160,8 @@
void SetIceRole(IceRole role);
IceRole ice_role() const { return ice_role_; }
- void SetIceTiebreaker(uint64 IceTiebreaker) { tiebreaker_ = IceTiebreaker; }
- uint64 IceTiebreaker() { return tiebreaker_; }
+ void SetIceTiebreaker(uint64_t IceTiebreaker) { tiebreaker_ = IceTiebreaker; }
+ uint64_t IceTiebreaker() { return tiebreaker_; }
void SetIceConfig(const IceConfig& config);
@@ -290,7 +290,7 @@
bool channels_destroyed_ = false;
bool connect_requested_ = false;
IceRole ice_role_ = ICEROLE_UNKNOWN;
- uint64 tiebreaker_ = 0;
+ uint64_t tiebreaker_ = 0;
IceMode remote_ice_mode_ = ICEMODE_FULL;
IceConfig ice_config_;
rtc::scoped_ptr<TransportDescription> local_description_;
diff --git a/webrtc/p2p/base/transportchannel.h b/webrtc/p2p/base/transportchannel.h
index ca7d7cf..1223618 100644
--- a/webrtc/p2p/base/transportchannel.h
+++ b/webrtc/p2p/base/transportchannel.h
@@ -124,11 +124,11 @@
// Allows key material to be extracted for external encryption.
virtual bool ExportKeyingMaterial(const std::string& label,
- const uint8* context,
- size_t context_len,
- bool use_context,
- uint8* result,
- size_t result_len) = 0;
+ const uint8_t* context,
+ size_t context_len,
+ bool use_context,
+ uint8_t* result,
+ size_t result_len) = 0;
// Signalled each time a packet is received on this channel.
sigslot::signal5<TransportChannel*, const char*,
diff --git a/webrtc/p2p/base/transportchannelimpl.h b/webrtc/p2p/base/transportchannelimpl.h
index ab3a31e..8d4d4bb 100644
--- a/webrtc/p2p/base/transportchannelimpl.h
+++ b/webrtc/p2p/base/transportchannelimpl.h
@@ -42,7 +42,7 @@
// For ICE channels.
virtual IceRole GetIceRole() const = 0;
virtual void SetIceRole(IceRole role) = 0;
- virtual void SetIceTiebreaker(uint64 tiebreaker) = 0;
+ virtual void SetIceTiebreaker(uint64_t tiebreaker) = 0;
// TODO(pthatcher): Remove this once it's no longer called in
// remoting/protocol/libjingle_transport_factory.cc
virtual void SetIceProtocolType(IceProtocolType type) {}
@@ -90,8 +90,8 @@
// Set DTLS Remote fingerprint. Must be after local identity set.
virtual bool SetRemoteFingerprint(const std::string& digest_alg,
- const uint8* digest,
- size_t digest_len) = 0;
+ const uint8_t* digest,
+ size_t digest_len) = 0;
virtual bool SetSslRole(rtc::SSLRole role) = 0;
diff --git a/webrtc/p2p/base/transportcontroller.h b/webrtc/p2p/base/transportcontroller.h
index 45fcfea..8d57b46 100644
--- a/webrtc/p2p/base/transportcontroller.h
+++ b/webrtc/p2p/base/transportcontroller.h
@@ -214,7 +214,7 @@
IceRole ice_role_ = ICEROLE_CONTROLLING;
// Flag which will be set to true after the first role switch
bool ice_role_switch_ = false;
- uint64 ice_tiebreaker_ = rtc::CreateRandomId64();
+ uint64_t ice_tiebreaker_ = rtc::CreateRandomId64();
rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
};
diff --git a/webrtc/p2p/base/turnport.cc b/webrtc/p2p/base/turnport.cc
index 2e4e26d..3fdcac5 100644
--- a/webrtc/p2p/base/turnport.cc
+++ b/webrtc/p2p/base/turnport.cc
@@ -38,7 +38,7 @@
// STUN_ERROR_ALLOCATION_MISMATCH error per rfc5766.
static const size_t MAX_ALLOCATE_MISMATCH_RETRIES = 2;
-inline bool IsTurnChannelData(uint16 msg_type) {
+inline bool IsTurnChannelData(uint16_t msg_type) {
return ((msg_type & 0xC000) == 0x4000); // MSB are 0b01
}
@@ -196,8 +196,8 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password,
const ProtocolAddress& server_address,
@@ -534,7 +534,7 @@
// Check the message type, to see if is a Channel Data message.
// The message will either be channel data, a TURN data indication, or
// a response to a previous request.
- uint16 msg_type = rtc::GetBE16(data);
+ uint16_t msg_type = rtc::GetBE16(data);
if (IsTurnChannelData(msg_type)) {
HandleChannelData(msg_type, data, size, packet_time);
} else if (msg_type == TURN_DATA_INDICATION) {
@@ -779,7 +779,7 @@
// +-------------------------------+
// Extract header fields from the message.
- uint16 len = rtc::GetBE16(data + 2);
+ uint16_t len = rtc::GetBE16(data + 2);
if (len > size - TURN_CHANNEL_HEADER_SIZE) {
LOG_J(LS_WARNING, this) << "Received TURN channel data message with "
<< "incorrect length, len=" << len;
@@ -1325,7 +1325,7 @@
} else {
// If the channel is bound, we can send the data as a Channel Message.
buf.WriteUInt16(channel_id_);
- buf.WriteUInt16(static_cast<uint16>(size));
+ buf.WriteUInt16(static_cast<uint16_t>(size));
buf.WriteBytes(reinterpret_cast<const char*>(data), size);
}
return port_->Send(buf.Data(), buf.Length(), options);
diff --git a/webrtc/p2p/base/turnport.h b/webrtc/p2p/base/turnport.h
index 52546e0..3bca727 100644
--- a/webrtc/p2p/base/turnport.h
+++ b/webrtc/p2p/base/turnport.h
@@ -57,8 +57,8 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username, // ice username.
const std::string& password, // ice password.
const ProtocolAddress& server_address,
@@ -149,8 +149,8 @@
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
- uint16 min_port,
- uint16 max_port,
+ uint16_t min_port,
+ uint16_t max_port,
const std::string& username,
const std::string& password,
const ProtocolAddress& server_address,
diff --git a/webrtc/p2p/base/turnserver.cc b/webrtc/p2p/base/turnserver.cc
index 7d82d55..8d40a90 100644
--- a/webrtc/p2p/base/turnserver.cc
+++ b/webrtc/p2p/base/turnserver.cc
@@ -40,7 +40,7 @@
static const size_t TURN_CHANNEL_HEADER_SIZE = 4U;
// TODO(mallinath) - Move these to a common place.
-inline bool IsTurnChannelData(uint16 msg_type) {
+inline bool IsTurnChannelData(uint16_t msg_type) {
// The first two bits of a channel data message are 0b01.
return ((msg_type & 0xC000) == 0x4000);
}
@@ -200,7 +200,7 @@
InternalSocketMap::iterator iter = server_sockets_.find(socket);
ASSERT(iter != server_sockets_.end());
TurnServerConnection conn(addr, iter->second, socket);
- uint16 msg_type = rtc::GetBE16(data);
+ uint16_t msg_type = rtc::GetBE16(data);
if (!IsTurnChannelData(msg_type)) {
// This is a STUN message.
HandleStunMessage(&conn, data, size);
@@ -394,7 +394,7 @@
std::string TurnServer::GenerateNonce() const {
// Generate a nonce of the form hex(now + HMAC-MD5(nonce_key_, now))
- uint32 now = rtc::Time();
+ uint32_t now = rtc::Time();
std::string input(reinterpret_cast<const char*>(&now), sizeof(now));
std::string nonce = rtc::hex_encode(input.c_str(), input.size());
nonce += rtc::ComputeHmac(rtc::DIGEST_MD5, nonce_key_, input);
@@ -409,7 +409,7 @@
}
// Decode the timestamp.
- uint32 then;
+ uint32_t then;
char* p = reinterpret_cast<char*>(&then);
size_t len = rtc::hex_decode(p, sizeof(then),
nonce.substr(0, sizeof(then) * 2));
@@ -761,7 +761,7 @@
void TurnServerAllocation::HandleChannelData(const char* data, size_t size) {
// Extract the channel number from the data.
- uint16 channel_id = rtc::GetBE16(data);
+ uint16_t channel_id = rtc::GetBE16(data);
Channel* channel = FindChannel(channel_id);
if (channel) {
// Send the data to the peer address.
@@ -784,7 +784,7 @@
// There is a channel bound to this address. Send as a channel message.
rtc::ByteBuffer buf;
buf.WriteUInt16(channel->id());
- buf.WriteUInt16(static_cast<uint16>(size));
+ buf.WriteUInt16(static_cast<uint16_t>(size));
buf.WriteBytes(data, size);
server_->Send(&conn_, buf);
} else if (HasPermission(addr.ipaddr())) {
@@ -806,7 +806,7 @@
int TurnServerAllocation::ComputeLifetime(const TurnMessage* msg) {
// Return the smaller of our default lifetime and the requested lifetime.
- uint32 lifetime = kDefaultAllocationTimeout / 1000; // convert to seconds
+ uint32_t lifetime = kDefaultAllocationTimeout / 1000; // convert to seconds
const StunUInt32Attribute* lifetime_attr = msg->GetUInt32(STUN_ATTR_LIFETIME);
if (lifetime_attr && lifetime_attr->value() < lifetime) {
lifetime = lifetime_attr->value();
diff --git a/webrtc/p2p/client/basicportallocator.cc b/webrtc/p2p/client/basicportallocator.cc
index f343b35..21c8921 100644
--- a/webrtc/p2p/client/basicportallocator.cc
+++ b/webrtc/p2p/client/basicportallocator.cc
@@ -59,7 +59,7 @@
} // namespace
namespace cricket {
-const uint32 DISABLE_ALL_PHASES =
+const uint32_t DISABLE_ALL_PHASES =
PORTALLOCATOR_DISABLE_UDP | PORTALLOCATOR_DISABLE_TCP |
PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_RELAY;
@@ -157,7 +157,7 @@
if (network_thread_ != NULL)
network_thread_->Clear(this);
- for (uint32 i = 0; i < sequences_.size(); ++i) {
+ for (uint32_t i = 0; i < sequences_.size(); ++i) {
// AllocationSequence should clear it's map entry for turn ports before
// ports are destroyed.
sequences_[i]->Clear();
@@ -167,10 +167,10 @@
for (it = ports_.begin(); it != ports_.end(); it++)
delete it->port();
- for (uint32 i = 0; i < configs_.size(); ++i)
+ for (uint32_t i = 0; i < configs_.size(); ++i)
delete configs_[i];
- for (uint32 i = 0; i < sequences_.size(); ++i)
+ for (uint32_t i = 0; i < sequences_.size(); ++i)
delete sequences_[i];
}
@@ -198,7 +198,7 @@
void BasicPortAllocatorSession::ClearGettingPorts() {
network_thread_->Clear(this, MSG_ALLOCATE);
- for (uint32 i = 0; i < sequences_.size(); ++i)
+ for (uint32_t i = 0; i < sequences_.size(); ++i)
sequences_[i]->Stop();
}
@@ -335,12 +335,12 @@
LOG(LS_WARNING) << "Machine has no networks; no ports will be allocated";
done_signal_needed = true;
} else {
- for (uint32 i = 0; i < networks.size(); ++i) {
+ for (uint32_t i = 0; i < networks.size(); ++i) {
PortConfiguration* config = NULL;
if (configs_.size() > 0)
config = configs_.back();
- uint32 sequence_flags = flags();
+ uint32_t sequence_flags = flags();
if ((sequence_flags & DISABLE_ALL_PHASES) == DISABLE_ALL_PHASES) {
// If all the ports are disabled we should just fire the allocation
// done event and return.
@@ -406,9 +406,12 @@
}
void BasicPortAllocatorSession::DisableEquivalentPhases(
- rtc::Network* network, PortConfiguration* config, uint32* flags) {
- for (uint32 i = 0; i < sequences_.size() &&
- (*flags & DISABLE_ALL_PHASES) != DISABLE_ALL_PHASES; ++i) {
+ rtc::Network* network,
+ PortConfiguration* config,
+ uint32_t* flags) {
+ for (uint32_t i = 0; i < sequences_.size() &&
+ (*flags & DISABLE_ALL_PHASES) != DISABLE_ALL_PHASES;
+ ++i) {
sequences_[i]->DisableEquivalentPhases(network, config, flags);
}
}
@@ -429,7 +432,7 @@
PORTALLOCATOR_ENABLE_STUN_RETRANSMIT_ATTRIBUTE) != 0);
// Push down the candidate_filter to individual port.
- uint32 candidate_filter = allocator_->candidate_filter();
+ uint32_t candidate_filter = allocator_->candidate_filter();
// When adapter enumeration is disabled, disable CF_HOST at port level so
// local address is not leaked by stunport in the candidate's related address.
@@ -572,7 +575,7 @@
}
bool BasicPortAllocatorSession::CheckCandidateFilter(const Candidate& c) {
- uint32 filter = allocator_->candidate_filter();
+ uint32_t filter = allocator_->candidate_filter();
// When binding to any address, before sending packets out, the getsockname
// returns all 0s, but after sending packets, it'll be the NIC used to
@@ -714,7 +717,7 @@
AllocationSequence::AllocationSequence(BasicPortAllocatorSession* session,
rtc::Network* network,
PortConfiguration* config,
- uint32 flags)
+ uint32_t flags)
: session_(session),
network_(network),
ip_(network->GetBestIP()),
@@ -757,7 +760,7 @@
}
void AllocationSequence::DisableEquivalentPhases(rtc::Network* network,
- PortConfiguration* config, uint32* flags) {
+ PortConfiguration* config, uint32_t* flags) {
if (network_removed_) {
// If the network of this allocation sequence has ever gone away,
// it won't be equivalent to the new network.
diff --git a/webrtc/p2p/client/basicportallocator.h b/webrtc/p2p/client/basicportallocator.h
index ac2cfbf..c8bcad2 100644
--- a/webrtc/p2p/client/basicportallocator.h
+++ b/webrtc/p2p/client/basicportallocator.h
@@ -171,7 +171,8 @@
void OnNetworksChanged();
void OnAllocationSequenceObjectsCreated();
void DisableEquivalentPhases(rtc::Network* network,
- PortConfiguration* config, uint32* flags);
+ PortConfiguration* config,
+ uint32_t* flags);
void AddAllocatedPort(Port* port, AllocationSequence* seq,
bool prepare_address);
void OnCandidateReady(Port* port, const Candidate& c);
@@ -258,7 +259,7 @@
AllocationSequence(BasicPortAllocatorSession* session,
rtc::Network* network,
PortConfiguration* config,
- uint32 flags);
+ uint32_t flags);
~AllocationSequence();
bool Init();
void Clear();
@@ -272,7 +273,7 @@
// equivalent network setup.
void DisableEquivalentPhases(rtc::Network* network,
PortConfiguration* config,
- uint32* flags);
+ uint32_t* flags);
// Starts and stops the sequence. When started, it will continue allocating
// new ports on its own timed schedule.
@@ -300,7 +301,7 @@
private:
typedef std::vector<ProtocolType> ProtocolList;
- bool IsFlagSet(uint32 flag) { return ((flags_ & flag) != 0); }
+ bool IsFlagSet(uint32_t flag) { return ((flags_ & flag) != 0); }
void CreateUDPPorts();
void CreateTCPPorts();
void CreateStunPorts();
@@ -321,7 +322,7 @@
rtc::IPAddress ip_;
PortConfiguration* config_;
State state_;
- uint32 flags_;
+ uint32_t flags_;
ProtocolList protocols_;
rtc::scoped_ptr<rtc::AsyncPacketSocket> udp_socket_;
// There will be only one udp port per AllocationSequence.
diff --git a/webrtc/p2p/client/portallocator_unittest.cc b/webrtc/p2p/client/portallocator_unittest.cc
index b0c77d3..9617688 100644
--- a/webrtc/p2p/client/portallocator_unittest.cc
+++ b/webrtc/p2p/client/portallocator_unittest.cc
@@ -249,7 +249,7 @@
// also the related address for TURN candidate if it is expected. Otherwise,
// it should be ignore.
void CheckDisableAdapterEnumeration(
- uint32 total_ports,
+ uint32_t total_ports,
const rtc::IPAddress& host_candidate_addr,
const rtc::IPAddress& stun_candidate_addr,
const rtc::IPAddress& relay_candidate_udp_transport_addr,
@@ -264,7 +264,7 @@
session_->StartGettingPorts();
EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
- uint32 total_candidates = 0;
+ uint32_t total_candidates = 0;
if (!host_candidate_addr.IsNil()) {
EXPECT_PRED5(CheckCandidate, candidates_[total_candidates],
cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp",
diff --git a/webrtc/p2p/client/socketmonitor.h b/webrtc/p2p/client/socketmonitor.h
index e0dd81e..eb11516 100644
--- a/webrtc/p2p/client/socketmonitor.h
+++ b/webrtc/p2p/client/socketmonitor.h
@@ -53,7 +53,7 @@
rtc::Thread* worker_thread_;
rtc::Thread* monitoring_thread_;
rtc::CriticalSection crit_;
- uint32 rate_;
+ uint32_t rate_;
bool monitoring_;
};
diff --git a/webrtc/p2p/stunprober/stunprober.cc b/webrtc/p2p/stunprober/stunprober.cc
index 5bfa711..d7d527a 100644
--- a/webrtc/p2p/stunprober/stunprober.cc
+++ b/webrtc/p2p/stunprober/stunprober.cc
@@ -44,16 +44,16 @@
// Each Request maps to a request and response.
struct Request {
// Actual time the STUN bind request was sent.
- int64 sent_time_ms = 0;
+ int64_t sent_time_ms = 0;
// Time the response was received.
- int64 received_time_ms = 0;
+ int64_t received_time_ms = 0;
// Server reflexive address from STUN response for this given request.
rtc::SocketAddress srflx_addr;
rtc::IPAddress server_addr;
- int64 rtt() { return received_time_ms - sent_time_ms; }
+ int64_t rtt() { return received_time_ms - sent_time_ms; }
void ProcessResponse(const char* buf, size_t buf_len);
};
@@ -97,8 +97,8 @@
std::vector<Request*> requests_;
std::vector<rtc::SocketAddress> server_ips_;
- int16 num_request_sent_ = 0;
- int16 num_response_received_ = 0;
+ int16_t num_request_sent_ = 0;
+ int16_t num_response_received_ = 0;
rtc::ThreadChecker& thread_checker_;
@@ -169,7 +169,7 @@
void StunProber::Requester::Request::ProcessResponse(const char* buf,
size_t buf_len) {
- int64 now = rtc::Time();
+ int64_t now = rtc::Time();
rtc::ByteBuffer message(buf, buf_len);
cricket::StunMessage stun_response;
if (!stun_response.Read(&message)) {
@@ -376,7 +376,7 @@
void StunProber::MaybeScheduleStunRequests() {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
- uint32 now = rtc::Time();
+ uint32_t now = rtc::Time();
if (Done()) {
invoker_.AsyncInvokeDelayed<void>(
@@ -404,8 +404,8 @@
StunProber::Stats stats;
int rtt_sum = 0;
- int64 first_sent_time = 0;
- int64 last_sent_time = 0;
+ int64_t first_sent_time = 0;
+ int64_t last_sent_time = 0;
NatType nat_type = NATTYPE_INVALID;
// Track of how many srflx IP that we have seen.
diff --git a/webrtc/p2p/stunprober/stunprober.h b/webrtc/p2p/stunprober/stunprober.h
index 88dedd5..b71d523 100644
--- a/webrtc/p2p/stunprober/stunprober.h
+++ b/webrtc/p2p/stunprober/stunprober.h
@@ -146,15 +146,15 @@
Requester* current_requester_ = nullptr;
// The time when the next request should go out.
- uint64 next_request_time_ms_ = 0;
+ uint64_t next_request_time_ms_ = 0;
// Total requests sent so far.
- uint32 num_request_sent_ = 0;
+ uint32_t num_request_sent_ = 0;
bool shared_socket_mode_ = false;
// How many requests should be done against each resolved IP.
- uint32 requests_per_ip_ = 0;
+ uint32_t requests_per_ip_ = 0;
// Milliseconds to pause between each STUN request.
int interval_ms_;
diff --git a/webrtc/p2p/stunprober/stunprober_unittest.cc b/webrtc/p2p/stunprober/stunprober_unittest.cc
index 3e03014..cdcc14a 100644
--- a/webrtc/p2p/stunprober/stunprober_unittest.cc
+++ b/webrtc/p2p/stunprober/stunprober_unittest.cc
@@ -59,8 +59,8 @@
const std::vector<rtc::SocketAddress>& addrs,
const rtc::NetworkManager::NetworkList& networks,
bool shared_socket,
- uint16 interval,
- uint16 pings_per_ip) {
+ uint16_t interval,
+ uint16_t pings_per_ip) {
prober.reset(
new StunProber(socket_factory, rtc::Thread::Current(), networks));
prober->Start(addrs, shared_socket, interval, pings_per_ip,
@@ -89,12 +89,12 @@
// Set up the expected results for verification.
std::set<std::string> srflx_addresses;
srflx_addresses.insert(kStunMappedAddr.ToString());
- const uint32 total_pings_tried =
- static_cast<uint32>(pings_per_ip * addrs.size());
+ const uint32_t total_pings_tried =
+ static_cast<uint32_t>(pings_per_ip * addrs.size());
// The reported total_pings should not count for pings sent to the
// kFailedStunAddr.
- const uint32 total_pings_reported = total_pings_tried - pings_per_ip;
+ const uint32_t total_pings_reported = total_pings_tried - pings_per_ip;
StartProbing(socket_factory.get(), addrs, networks, shared_mode, 3,
pings_per_ip);
@@ -106,9 +106,9 @@
EXPECT_EQ(stats.success_percent, 100);
EXPECT_TRUE(stats.nat_type > stunprober::NATTYPE_NONE);
EXPECT_EQ(stats.srflx_addrs, srflx_addresses);
- EXPECT_EQ(static_cast<uint32>(stats.num_request_sent),
+ EXPECT_EQ(static_cast<uint32_t>(stats.num_request_sent),
total_pings_reported);
- EXPECT_EQ(static_cast<uint32>(stats.num_response_received),
+ EXPECT_EQ(static_cast<uint32_t>(stats.num_response_received),
total_pings_reported);
}
diff --git a/webrtc/tools/converter/converter.cc b/webrtc/tools/converter/converter.cc
index 6c9154c..a9b453d 100644
--- a/webrtc/tools/converter/converter.cc
+++ b/webrtc/tools/converter/converter.cc
@@ -45,13 +45,13 @@
}
int input_frame_size = InputFrameSize();
- uint8* rgba_buffer = new uint8[input_frame_size];
+ uint8_t* rgba_buffer = new uint8_t[input_frame_size];
int y_plane_size = YPlaneSize();
- uint8* dst_y = new uint8[y_plane_size];
+ uint8_t* dst_y = new uint8_t[y_plane_size];
int u_plane_size = UPlaneSize();
- uint8* dst_u = new uint8[u_plane_size];
+ uint8_t* dst_u = new uint8_t[u_plane_size];
int v_plane_size = VPlaneSize();
- uint8* dst_v = new uint8[v_plane_size];
+ uint8_t* dst_v = new uint8_t[v_plane_size];
int counter = 0; // Counter to form frame names.
bool success = false; // Is conversion successful.
@@ -106,9 +106,12 @@
return success;
}
-bool Converter::AddYUVToFile(uint8* y_plane, int y_plane_size,
- uint8* u_plane, int u_plane_size,
- uint8* v_plane, int v_plane_size,
+bool Converter::AddYUVToFile(uint8_t* y_plane,
+ int y_plane_size,
+ uint8_t* u_plane,
+ int u_plane_size,
+ uint8_t* v_plane,
+ int v_plane_size,
FILE* output_file) {
bool success = AddYUVPlaneToFile(y_plane, y_plane_size, output_file) &&
AddYUVPlaneToFile(u_plane, u_plane_size, output_file) &&
@@ -116,7 +119,8 @@
return success;
}
-bool Converter::AddYUVPlaneToFile(uint8* yuv_plane, int yuv_plane_size,
+bool Converter::AddYUVPlaneToFile(uint8_t* yuv_plane,
+ int yuv_plane_size,
FILE* file) {
size_t bytes_written = fwrite(yuv_plane, 1, yuv_plane_size, file);
diff --git a/webrtc/tools/converter/converter.h b/webrtc/tools/converter/converter.h
index a23d5a1..f7641ff 100644
--- a/webrtc/tools/converter/converter.h
+++ b/webrtc/tools/converter/converter.h
@@ -75,13 +75,16 @@
// Writes the Y, U and V (in this order) planes to the file, thus adding a
// raw YUV frame to the file.
- bool AddYUVToFile(uint8* y_plane, int y_plane_size,
- uint8* u_plane, int u_plane_size,
- uint8* v_plane, int v_plane_size,
+ bool AddYUVToFile(uint8_t* y_plane,
+ int y_plane_size,
+ uint8_t* u_plane,
+ int u_plane_size,
+ uint8_t* v_plane,
+ int v_plane_size,
FILE* output_file);
// Adds the Y, U or V plane to the file.
- bool AddYUVPlaneToFile(uint8* yuv_plane, int yuv_plane_size, FILE* file);
+ bool AddYUVPlaneToFile(uint8_t* yuv_plane, int yuv_plane_size, FILE* file);
// Reads a RGBA frame from input_file_name with input_frame_size size in bytes
// into the buffer.
diff --git a/webrtc/tools/frame_analyzer/video_quality_analysis.cc b/webrtc/tools/frame_analyzer/video_quality_analysis.cc
index 5c707bb..172baa7 100644
--- a/webrtc/tools/frame_analyzer/video_quality_analysis.cc
+++ b/webrtc/tools/frame_analyzer/video_quality_analysis.cc
@@ -90,8 +90,11 @@
return true;
}
-bool ExtractFrameFromYuvFile(const char* i420_file_name, int width, int height,
- int frame_number, uint8* result_frame) {
+bool ExtractFrameFromYuvFile(const char* i420_file_name,
+ int width,
+ int height,
+ int frame_number,
+ uint8_t* result_frame) {
int frame_size = GetI420FrameSize(width, height);
int offset = frame_number * frame_size; // Calculate offset for the frame.
bool errors = false;
@@ -117,8 +120,11 @@
return !errors;
}
-bool ExtractFrameFromY4mFile(const char* y4m_file_name, int width, int height,
- int frame_number, uint8* result_frame) {
+bool ExtractFrameFromY4mFile(const char* y4m_file_name,
+ int width,
+ int height,
+ int frame_number,
+ uint8_t* result_frame) {
int frame_size = GetI420FrameSize(width, height);
int frame_offset = frame_number * frame_size;
bool errors = false;
@@ -170,20 +176,22 @@
}
double CalculateMetrics(VideoAnalysisMetricsType video_metrics_type,
- const uint8* ref_frame, const uint8* test_frame,
- int width, int height) {
+ const uint8_t* ref_frame,
+ const uint8_t* test_frame,
+ int width,
+ int height) {
if (!ref_frame || !test_frame)
return -1;
else if (height < 0 || width < 0)
return -1;
int half_width = (width + 1) >> 1;
int half_height = (height + 1) >> 1;
- const uint8* src_y_a = ref_frame;
- const uint8* src_u_a = src_y_a + width * height;
- const uint8* src_v_a = src_u_a + half_width * half_height;
- const uint8* src_y_b = test_frame;
- const uint8* src_u_b = src_y_b + width * height;
- const uint8* src_v_b = src_u_b + half_width * half_height;
+ const uint8_t* src_y_a = ref_frame;
+ const uint8_t* src_u_a = src_y_a + width * height;
+ const uint8_t* src_v_a = src_u_a + half_width * half_height;
+ const uint8_t* src_y_b = test_frame;
+ const uint8_t* src_u_b = src_y_b + width * height;
+ const uint8_t* src_v_b = src_u_b + half_width * half_height;
int stride_y = width;
int stride_uv = half_width;
@@ -230,8 +238,8 @@
char line[STATS_LINE_LENGTH];
// Allocate buffers for test and reference frames.
- uint8* test_frame = new uint8[size];
- uint8* reference_frame = new uint8[size];
+ uint8_t* test_frame = new uint8_t[size];
+ uint8_t* reference_frame = new uint8_t[size];
int previous_frame_number = -1;
// While there are entries in the stats file.
diff --git a/webrtc/tools/frame_analyzer/video_quality_analysis.h b/webrtc/tools/frame_analyzer/video_quality_analysis.h
index 49b6f12..475b2fa 100644
--- a/webrtc/tools/frame_analyzer/video_quality_analysis.h
+++ b/webrtc/tools/frame_analyzer/video_quality_analysis.h
@@ -62,8 +62,10 @@
// frames are exactly the same) will be 48. In the case of SSIM the max return
// value will be 1.
double CalculateMetrics(VideoAnalysisMetricsType video_metrics_type,
- const uint8* ref_frame, const uint8* test_frame,
- int width, int height);
+ const uint8_t* ref_frame,
+ const uint8_t* test_frame,
+ int width,
+ int height);
// Prints the result from the analysis in Chromium performance
// numbers compatible format to stdout. If the results object contains no frames
@@ -101,14 +103,19 @@
int ExtractDecodedFrameNumber(std::string line);
// Extracts an I420 frame at position frame_number from the raw YUV file.
-bool ExtractFrameFromYuvFile(const char* i420_file_name, int width, int height,
- int frame_number, uint8* result_frame);
+bool ExtractFrameFromYuvFile(const char* i420_file_name,
+ int width,
+ int height,
+ int frame_number,
+ uint8_t* result_frame);
// Extracts an I420 frame at position frame_number from the Y4M file. The first
// frame has corresponded |frame_number| 0.
-bool ExtractFrameFromY4mFile(const char* i420_file_name, int width, int height,
- int frame_number, uint8* result_frame);
-
+bool ExtractFrameFromY4mFile(const char* i420_file_name,
+ int width,
+ int height,
+ int frame_number,
+ uint8_t* result_frame);
} // namespace test
} // namespace webrtc
diff --git a/webrtc/tools/psnr_ssim_analyzer/psnr_ssim_analyzer.cc b/webrtc/tools/psnr_ssim_analyzer/psnr_ssim_analyzer.cc
index 3fb468b..bae145a 100644
--- a/webrtc/tools/psnr_ssim_analyzer/psnr_ssim_analyzer.cc
+++ b/webrtc/tools/psnr_ssim_analyzer/psnr_ssim_analyzer.cc
@@ -34,8 +34,8 @@
int size = webrtc::test::GetI420FrameSize(width, height);
// Allocate buffers for test and reference frames.
- uint8* test_frame = new uint8[size];
- uint8* ref_frame = new uint8[size];
+ uint8_t* test_frame = new uint8_t[size];
+ uint8_t* ref_frame = new uint8_t[size];
bool read_result = true;
for(int frame_counter = 0; frame_counter < MAX_NUM_FRAMES_PER_FILE;
diff --git a/webrtc/typedefs.h b/webrtc/typedefs.h
index 3034c7e..d875490 100644
--- a/webrtc/typedefs.h
+++ b/webrtc/typedefs.h
@@ -62,19 +62,8 @@
#define WEBRTC_CPU_DETECTION
#endif
-#if !defined(_MSC_VER)
+// TODO(pbos): Use webrtc/base/basictypes.h instead to include fixed-size ints.
#include <stdint.h>
-#else
-// Define C99 equivalent types, since pre-2010 MSVC doesn't provide stdint.h.
-typedef signed char int8_t;
-typedef signed short int16_t;
-typedef signed int int32_t;
-typedef __int64 int64_t;
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned __int64 uint64_t;
-#endif
// Annotate a function indicating the caller must examine the return value.
// Use like:
diff --git a/webrtc/voice_engine/test/auto_test/fakes/conference_transport.cc b/webrtc/voice_engine/test/auto_test/fakes/conference_transport.cc
index 581a768..0677093 100644
--- a/webrtc/voice_engine/test/auto_test/fakes/conference_transport.cc
+++ b/webrtc/voice_engine/test/auto_test/fakes/conference_transport.cc
@@ -207,8 +207,8 @@
packet_queue_.pop_front();
}
- int32 elapsed_time_ms = rtc::TimeSince(packet.send_time_ms_);
- int32 sleep_ms = rtt_ms_ / 2 - elapsed_time_ms;
+ int32_t elapsed_time_ms = rtc::TimeSince(packet.send_time_ms_);
+ int32_t sleep_ms = rtt_ms_ / 2 - elapsed_time_ms;
if (sleep_ms > 0) {
// Every packet should be delayed by half of RTT.
webrtc::SleepMs(sleep_ms);
diff --git a/webrtc/voice_engine/test/auto_test/fakes/conference_transport.h b/webrtc/voice_engine/test/auto_test/fakes/conference_transport.h
index 602f07f..2194de9 100644
--- a/webrtc/voice_engine/test/auto_test/fakes/conference_transport.h
+++ b/webrtc/voice_engine/test/auto_test/fakes/conference_transport.h
@@ -108,7 +108,7 @@
enum Type { Rtp, Rtcp, } type_;
Packet() : len_(0) {}
- Packet(Type type, const void* data, size_t len, uint32 time_ms)
+ Packet(Type type, const void* data, size_t len, uint32_t time_ms)
: type_(type), len_(len), send_time_ms_(time_ms) {
EXPECT_LE(len_, kMaxPacketSizeByte);
memcpy(data_, data, len_);
@@ -116,7 +116,7 @@
uint8_t data_[kMaxPacketSizeByte];
size_t len_;
- uint32 send_time_ms_;
+ uint32_t send_time_ms_;
};
static bool Run(void* transport) {
diff --git a/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.cc b/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.cc
index 9d7239e..d4438a4 100644
--- a/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.cc
+++ b/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.cc
@@ -14,7 +14,7 @@
namespace voetest {
-void LoudestFilter::RemoveTimeoutStreams(uint32 time_ms) {
+void LoudestFilter::RemoveTimeoutStreams(uint32_t time_ms) {
auto it = stream_levels_.begin();
while (it != stream_levels_.end()) {
if (rtc::TimeDiff(time_ms, it->second.last_time_ms) >
@@ -41,7 +41,7 @@
}
bool LoudestFilter::ForwardThisPacket(const webrtc::RTPHeader& rtp_header) {
- uint32 time_now_ms = rtc::Time();
+ uint32_t time_now_ms = rtc::Time();
RemoveTimeoutStreams(time_now_ms);
int source_ssrc = rtp_header.ssrc;
diff --git a/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.h b/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.h
index 79b0105..73b801c 100644
--- a/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.h
+++ b/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.h
@@ -29,21 +29,21 @@
private:
struct Status {
- void Set(int audio_level, uint32 last_time_ms) {
+ void Set(int audio_level, uint32_t last_time_ms) {
this->audio_level = audio_level;
this->last_time_ms = last_time_ms;
}
int audio_level;
- uint32 last_time_ms;
+ uint32_t last_time_ms;
};
- void RemoveTimeoutStreams(uint32 time_ms);
+ void RemoveTimeoutStreams(uint32_t time_ms);
unsigned int FindQuietestStream();
// Keeps the streams being forwarded in pair<SSRC, Status>.
std::map<unsigned int, Status> stream_levels_;
- const int32 kStreamTimeOutMs = 5000;
+ const int32_t kStreamTimeOutMs = 5000;
const size_t kMaxMixSize = 3;
const int kInvalidAudioLevel = 128;
};
diff --git a/webrtc/voice_engine/test/auto_test/voe_conference_test.cc b/webrtc/voice_engine/test/auto_test/voe_conference_test.cc
index d2407f3..f9d2271 100644
--- a/webrtc/voice_engine/test/auto_test/voe_conference_test.cc
+++ b/webrtc/voice_engine/test/auto_test/voe_conference_test.cc
@@ -72,7 +72,7 @@
const int kStatsRequestIntervalMs = 1000;
const int kStatsBufferSize = 3;
- uint32 deadline = rtc::TimeAfter(kMaxRunTimeMs);
+ uint32_t deadline = rtc::TimeAfter(kMaxRunTimeMs);
// Run the following up to |kMaxRunTimeMs| milliseconds.
int successive_pass = 0;
webrtc::CallStatistics stats_1;
