admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Split ByteBuffer into writer/reader objects.

Browse Source 
This allows the reader to reference data, thus avoiding unnecessary
allocations and memory copies.

BUG=webrtc:5155,webrtc:5670

Review URL: https://codereview.webrtc.org/1821083002

Cr-Commit-Position: refs/heads/master@{#12160}
This commit is contained in:
jbauch 2016-03-30 06:43:37 -07:00 committed by Commit bot
parent 0d05da7ee6
commit f1f87203d7
33 changed files with 488 additions and 454 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
webrtc/api/sctputils.cc
View File

@ -49,9 +49,7 @@ bool ParseDataChannelOpenMessage(const rtc::CopyOnWriteBuffer& payload,
// Format defined at
// http://tools.ietf.org/html/draft-jesup-rtcweb-data-protocol-04
// TODO(jbauch): avoid copying the payload data into the ByteBuffer, see
// https://bugs.chromium.org/p/webrtc/issues/detail?id=5670
rtc::ByteBuffer buffer(payload.data<char>(), payload.size());
rtc::ByteBufferReader buffer(payload.data<char>(), payload.size());
uint8_t message_type;
if (!buffer.ReadUInt8(&message_type)) {
LOG(LS_WARNING) << "Could not read OPEN message type.";
@ -166,7 +164,7 @@ bool WriteDataChannelOpenMessage(const std::string& label,
}
}
rtc::ByteBuffer buffer(
rtc::ByteBufferWriter buffer(
NULL, 20 + label.length() + config.protocol.length(),
rtc::ByteBuffer::ORDER_NETWORK);
// TODO(tommi): Add error handling and check resulting length.

2
webrtc/base/bitbuffer_unittest.cc
View File

@ -188,7 +188,7 @@ uint64_t GolombEncoded(uint32_t val) {
}
TEST(BitBufferTest, GolombUint32Values) {
ByteBuffer byteBuffer;
ByteBufferWriter byteBuffer;
byteBuffer.Resize(16);
BitBuffer buffer(reinterpret_cast<const uint8_t*>(byteBuffer.Data()),
byteBuffer.Capacity());

286
webrtc/base/bytebuffer.cc
View File

@ -22,36 +22,30 @@ namespace rtc {
static const int DEFAULT_SIZE = 4096;
ByteBuffer::ByteBuffer() {
Construct(NULL, DEFAULT_SIZE, ORDER_NETWORK);
ByteBufferWriter::ByteBufferWriter()
: ByteBuffer(ORDER_NETWORK) {
Construct(NULL, DEFAULT_SIZE);
}
ByteBuffer::ByteBuffer(ByteOrder byte_order) {
Construct(NULL, DEFAULT_SIZE, byte_order);
ByteBufferWriter::ByteBufferWriter(ByteOrder byte_order)
: ByteBuffer(byte_order) {
Construct(NULL, DEFAULT_SIZE);
}
ByteBuffer::ByteBuffer(const char* bytes, size_t len) {
Construct(bytes, len, ORDER_NETWORK);
ByteBufferWriter::ByteBufferWriter(const char* bytes, size_t len)
: ByteBuffer(ORDER_NETWORK) {
Construct(bytes, len);
}
ByteBuffer::ByteBuffer(const char* bytes, size_t len, ByteOrder byte_order) {
Construct(bytes, len, byte_order);
ByteBufferWriter::ByteBufferWriter(const char* bytes, size_t len,
ByteOrder byte_order)
: ByteBuffer(byte_order) {
Construct(bytes, len);
}
ByteBuffer::ByteBuffer(const char* bytes) {
Construct(bytes, strlen(bytes), ORDER_NETWORK);
}
ByteBuffer::ByteBuffer(const Buffer& buf) {
Construct(buf.data<char>(), buf.size(), ORDER_NETWORK);
}
void ByteBuffer::Construct(const char* bytes, size_t len,
ByteOrder byte_order) {
version_ = 0;
void ByteBufferWriter::Construct(const char* bytes, size_t len) {
start_ = 0;
size_ = len;
byte_order_ = byte_order;
bytes_ = new char[size_];
if (bytes) {
@ -62,128 +56,47 @@ void ByteBuffer::Construct(const char* bytes, size_t len,
}
}
ByteBuffer::~ByteBuffer() {
ByteBufferWriter::~ByteBufferWriter() {
delete[] bytes_;
}
bool ByteBuffer::ReadUInt8(uint8_t* val) {
if (!val) return false;
return ReadBytes(reinterpret_cast<char*>(val), 1);
}
bool ByteBuffer::ReadUInt16(uint16_t* val) {
if (!val) return false;
uint16_t v;
if (!ReadBytes(reinterpret_cast<char*>(&v), 2)) {
return false;
} else {
*val = (byte_order_ == ORDER_NETWORK) ? NetworkToHost16(v) : v;
return true;
}
}
bool ByteBuffer::ReadUInt24(uint32_t* val) {
if (!val) return false;
uint32_t v = 0;
char* read_into = reinterpret_cast<char*>(&v);
if (byte_order_ == ORDER_NETWORK || IsHostBigEndian()) {
++read_into;
}
if (!ReadBytes(read_into, 3)) {
return false;
} else {
*val = (byte_order_ == ORDER_NETWORK) ? NetworkToHost32(v) : v;
return true;
}
}
bool ByteBuffer::ReadUInt32(uint32_t* val) {
if (!val) return false;
uint32_t v;
if (!ReadBytes(reinterpret_cast<char*>(&v), 4)) {
return false;
} else {
*val = (byte_order_ == ORDER_NETWORK) ? NetworkToHost32(v) : v;
return true;
}
}
bool ByteBuffer::ReadUInt64(uint64_t* val) {
if (!val) return false;
uint64_t v;
if (!ReadBytes(reinterpret_cast<char*>(&v), 8)) {
return false;
} else {
*val = (byte_order_ == ORDER_NETWORK) ? NetworkToHost64(v) : v;
return true;
}
}
bool ByteBuffer::ReadString(std::string* val, size_t len) {
if (!val) return false;
if (len > Length()) {
return false;
} else {
val->append(bytes_ + start_, len);
start_ += len;
return true;
}
}
bool ByteBuffer::ReadBytes(char* val, size_t len) {
if (len > Length()) {
return false;
} else {
memcpy(val, bytes_ + start_, len);
start_ += len;
return true;
}
}
void ByteBuffer::WriteUInt8(uint8_t val) {
void ByteBufferWriter::WriteUInt8(uint8_t val) {
WriteBytes(reinterpret_cast<const char*>(&val), 1);
}
void ByteBuffer::WriteUInt16(uint16_t val) {
uint16_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork16(val) : val;
void ByteBufferWriter::WriteUInt16(uint16_t val) {
uint16_t v = (Order() == ORDER_NETWORK) ? HostToNetwork16(val) : val;
WriteBytes(reinterpret_cast<const char*>(&v), 2);
}
void ByteBuffer::WriteUInt24(uint32_t val) {
uint32_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork32(val) : val;
void ByteBufferWriter::WriteUInt24(uint32_t val) {
uint32_t v = (Order() == ORDER_NETWORK) ? HostToNetwork32(val) : val;
char* start = reinterpret_cast<char*>(&v);
if (byte_order_ == ORDER_NETWORK || IsHostBigEndian()) {
if (Order() == ORDER_NETWORK || IsHostBigEndian()) {
++start;
}
WriteBytes(start, 3);
}
void ByteBuffer::WriteUInt32(uint32_t val) {
uint32_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork32(val) : val;
void ByteBufferWriter::WriteUInt32(uint32_t val) {
uint32_t v = (Order() == ORDER_NETWORK) ? HostToNetwork32(val) : val;
WriteBytes(reinterpret_cast<const char*>(&v), 4);
}
void ByteBuffer::WriteUInt64(uint64_t val) {
uint64_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork64(val) : val;
void ByteBufferWriter::WriteUInt64(uint64_t val) {
uint64_t v = (Order() == ORDER_NETWORK) ? HostToNetwork64(val) : val;
WriteBytes(reinterpret_cast<const char*>(&v), 8);
}
void ByteBuffer::WriteString(const std::string& val) {
void ByteBufferWriter::WriteString(const std::string& val) {
WriteBytes(val.c_str(), val.size());
}
void ByteBuffer::WriteBytes(const char* val, size_t len) {
void ByteBufferWriter::WriteBytes(const char* val, size_t len) {
memcpy(ReserveWriteBuffer(len), val, len);
}
char* ByteBuffer::ReserveWriteBuffer(size_t len) {
char* ByteBufferWriter::ReserveWriteBuffer(size_t len) {
if (Length() + len > Capacity())
Resize(Length() + len);
@ -192,7 +105,7 @@ char* ByteBuffer::ReserveWriteBuffer(size_t len) {
return start;
}
void ByteBuffer::Resize(size_t size) {
void ByteBufferWriter::Resize(size_t size) {
size_t len = std::min(end_ - start_, size);
if (size <= size_) {
// Don't reallocate, just move data backwards
@ -207,32 +120,133 @@ void ByteBuffer::Resize(size_t size) {
}
start_ = 0;
end_ = len;
++version_;
}
bool ByteBuffer::Consume(size_t size) {
void ByteBufferWriter::Clear() {
memset(bytes_, 0, size_);
start_ = end_ = 0;
}
ByteBufferReader::ByteBufferReader(const char* bytes, size_t len)
: ByteBuffer(ORDER_NETWORK) {
Construct(bytes, len);
}
ByteBufferReader::ByteBufferReader(const char* bytes, size_t len,
ByteOrder byte_order)
: ByteBuffer(byte_order) {
Construct(bytes, len);
}
ByteBufferReader::ByteBufferReader(const char* bytes)
: ByteBuffer(ORDER_NETWORK) {
Construct(bytes, strlen(bytes));
}
ByteBufferReader::ByteBufferReader(const Buffer& buf)
: ByteBuffer(ORDER_NETWORK) {
Construct(buf.data<char>(), buf.size());
}
ByteBufferReader::ByteBufferReader(const ByteBufferWriter& buf)
: ByteBuffer(buf.Order()) {
Construct(buf.Data(), buf.Length());
}
void ByteBufferReader::Construct(const char* bytes, size_t len) {
bytes_ = bytes;
size_ = len;
start_ = 0;
end_ = len;
}
bool ByteBufferReader::ReadUInt8(uint8_t* val) {
if (!val) return false;
return ReadBytes(reinterpret_cast<char*>(val), 1);
}
bool ByteBufferReader::ReadUInt16(uint16_t* val) {
if (!val) return false;
uint16_t v;
if (!ReadBytes(reinterpret_cast<char*>(&v), 2)) {
return false;
} else {
*val = (Order() == ORDER_NETWORK) ? NetworkToHost16(v) : v;
return true;
}
}
bool ByteBufferReader::ReadUInt24(uint32_t* val) {
if (!val) return false;
uint32_t v = 0;
char* read_into = reinterpret_cast<char*>(&v);
if (Order() == ORDER_NETWORK || IsHostBigEndian()) {
++read_into;
}
if (!ReadBytes(read_into, 3)) {
return false;
} else {
*val = (Order() == ORDER_NETWORK) ? NetworkToHost32(v) : v;
return true;
}
}
bool ByteBufferReader::ReadUInt32(uint32_t* val) {
if (!val) return false;
uint32_t v;
if (!ReadBytes(reinterpret_cast<char*>(&v), 4)) {
return false;
} else {
*val = (Order() == ORDER_NETWORK) ? NetworkToHost32(v) : v;
return true;
}
}
bool ByteBufferReader::ReadUInt64(uint64_t* val) {
if (!val) return false;
uint64_t v;
if (!ReadBytes(reinterpret_cast<char*>(&v), 8)) {
return false;
} else {
*val = (Order() == ORDER_NETWORK) ? NetworkToHost64(v) : v;
return true;
}
}
bool ByteBufferReader::ReadString(std::string* val, size_t len) {
if (!val) return false;
if (len > Length()) {
return false;
} else {
val->append(bytes_ + start_, len);
start_ += len;
return true;
}
}
bool ByteBufferReader::ReadBytes(char* val, size_t len) {
if (len > Length()) {
return false;
} else {
memcpy(val, bytes_ + start_, len);
start_ += len;
return true;
}
}
bool ByteBufferReader::Consume(size_t size) {
if (size > Length())
return false;
start_ += size;
return true;
}
ByteBuffer::ReadPosition ByteBuffer::GetReadPosition() const {
return ReadPosition(start_, version_);
}
bool ByteBuffer::SetReadPosition(const ReadPosition &position) {
if (position.version_ != version_) {
return false;
}
start_ = position.start_;
return true;
}
void ByteBuffer::Clear() {
memset(bytes_, 0, size_);
start_ = end_ = 0;
++version_;
}
} // namespace rtc

130
webrtc/base/bytebuffer.h
View File

@ -21,29 +21,87 @@ namespace rtc {
class ByteBuffer {
public:
enum ByteOrder {
ORDER_NETWORK = 0, // Default, use network byte order (big endian).
ORDER_HOST, // Use the native order of the host.
};
explicit ByteBuffer(ByteOrder byte_order) : byte_order_(byte_order) {}
ByteOrder Order() const { return byte_order_; }
private:
ByteOrder byte_order_;
RTC_DISALLOW_COPY_AND_ASSIGN(ByteBuffer);
};
class ByteBufferWriter : public ByteBuffer {
public:
// |byte_order| defines order of bytes in the buffer.
ByteBuffer();
explicit ByteBuffer(ByteOrder byte_order);
ByteBuffer(const char* bytes, size_t len);
ByteBuffer(const char* bytes, size_t len, ByteOrder byte_order);
ByteBufferWriter();
explicit ByteBufferWriter(ByteOrder byte_order);
ByteBufferWriter(const char* bytes, size_t len);
ByteBufferWriter(const char* bytes, size_t len, ByteOrder byte_order);
// Initializes buffer from a zero-terminated string.
explicit ByteBuffer(const char* bytes);
explicit ByteBuffer(const Buffer& buf);
~ByteBuffer();
~ByteBufferWriter();
const char* Data() const { return bytes_ + start_; }
size_t Length() const { return end_ - start_; }
size_t Capacity() const { return size_ - start_; }
ByteOrder Order() const { return byte_order_; }
// Write value to the buffer. Resizes the buffer when it is
// neccessary.
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);
// Reserves the given number of bytes and returns a char* that can be written
// into. Useful for functions that require a char* buffer and not a
// ByteBufferWriter.
char* ReserveWriteBuffer(size_t len);
// Resize the buffer to the specified |size|.
void Resize(size_t size);
// Clears the contents of the buffer. After this, Length() will be 0.
void Clear();
private:
void Construct(const char* bytes, size_t size);
char* bytes_;
size_t size_;
size_t start_;
size_t end_;
// There are sensible ways to define these, but they aren't needed in our code
// base.
RTC_DISALLOW_COPY_AND_ASSIGN(ByteBufferWriter);
};
// The ByteBufferReader references the passed data, i.e. the pointer must be
// valid during the lifetime of the reader.
class ByteBufferReader : public ByteBuffer {
public:
ByteBufferReader(const char* bytes, size_t len);
ByteBufferReader(const char* bytes, size_t len, ByteOrder byte_order);
// Initializes buffer from a zero-terminated string.
explicit ByteBufferReader(const char* bytes);
explicit ByteBufferReader(const Buffer& buf);
explicit ByteBufferReader(const ByteBufferWriter& buf);
// Returns start of unprocessed data.
const char* Data() const { return bytes_ + start_; }
// Returns number of unprocessed bytes.
size_t Length() const { return end_ - start_; }
// Read a next value from the buffer. Return false if there isn't
// enough data left for the specified type.
@ -58,63 +116,21 @@ class ByteBuffer {
// if there is less than |len| bytes left.
bool ReadString(std::string* val, size_t len);
// Write value to the buffer. Resizes the buffer when it is
// neccessary.
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);
// Reserves the given number of bytes and returns a char* that can be written
// into. Useful for functions that require a char* buffer and not a
// ByteBuffer.
char* ReserveWriteBuffer(size_t len);
// Resize the buffer to the specified |size|. This invalidates any remembered
// seek positions.
void Resize(size_t size);
// Moves current position |size| bytes forward. Returns false if
// there is less than |size| bytes left in the buffer. Consume doesn't
// permanently remove data, so remembered read positions are still valid
// after this call.
bool Consume(size_t size);
// Clears the contents of the buffer. After this, Length() will be 0.
void Clear();
// Used with GetReadPosition/SetReadPosition.
class ReadPosition {
friend class ByteBuffer;
ReadPosition(size_t start, int version)
: start_(start), version_(version) { }
size_t start_;
int version_;
};
// Remembers the current read position for a future SetReadPosition. Any
// calls to Shift or Resize in the interim will invalidate the position.
ReadPosition GetReadPosition() const;
// If the given position is still valid, restores that read position.
bool SetReadPosition(const ReadPosition &position);
private:
void Construct(const char* bytes, size_t size, ByteOrder byte_order);
void Construct(const char* bytes, size_t size);
char* bytes_;
const char* bytes_;
size_t size_;
size_t start_;
size_t end_;
int version_;
ByteOrder byte_order_;
// There are sensible ways to define these, but they aren't needed in our code
// base.
RTC_DISALLOW_COPY_AND_ASSIGN(ByteBuffer);
RTC_DISALLOW_COPY_AND_ASSIGN(ByteBufferReader);
};
} // namespace rtc

107
webrtc/base/bytebuffer_unittest.cc
View File

@ -54,7 +54,7 @@ TEST(ByteBufferTest, TestByteOrder) {
}
TEST(ByteBufferTest, TestBufferLength) {
ByteBuffer buffer;
ByteBufferWriter buffer;
size_t size = 0;
EXPECT_EQ(size, buffer.Length());
@ -77,117 +77,102 @@ TEST(ByteBufferTest, TestBufferLength) {
buffer.WriteUInt64(1);
size += 8;
EXPECT_EQ(size, buffer.Length());
EXPECT_TRUE(buffer.Consume(0));
EXPECT_EQ(size, buffer.Length());
EXPECT_TRUE(buffer.Consume(4));
size -= 4;
EXPECT_EQ(size, buffer.Length());
}
TEST(ByteBufferTest, TestGetSetReadPosition) {
ByteBuffer buffer("ABCDEF", 6);
EXPECT_EQ(6U, buffer.Length());
ByteBuffer::ReadPosition pos(buffer.GetReadPosition());
EXPECT_TRUE(buffer.SetReadPosition(pos));
EXPECT_EQ(6U, buffer.Length());
std::string read;
EXPECT_TRUE(buffer.ReadString(&read, 3));
EXPECT_EQ("ABC", read);
EXPECT_EQ(3U, buffer.Length());
EXPECT_TRUE(buffer.SetReadPosition(pos));
EXPECT_EQ(6U, buffer.Length());
read.clear();
EXPECT_TRUE(buffer.ReadString(&read, 3));
EXPECT_EQ("ABC", read);
EXPECT_EQ(3U, buffer.Length());
// For a resize by writing Capacity() number of bytes.
size_t capacity = buffer.Capacity();
buffer.ReserveWriteBuffer(buffer.Capacity());
EXPECT_EQ(capacity + 3U, buffer.Length());
EXPECT_FALSE(buffer.SetReadPosition(pos));
read.clear();
EXPECT_TRUE(buffer.ReadString(&read, 3));
EXPECT_EQ("DEF", read);
}
TEST(ByteBufferTest, TestReadWriteBuffer) {
ByteBuffer::ByteOrder orders[2] = { ByteBuffer::ORDER_HOST,
ByteBuffer::ORDER_NETWORK };
ByteBufferWriter::ByteOrder orders[2] = { ByteBufferWriter::ORDER_HOST,
ByteBufferWriter::ORDER_NETWORK };
for (size_t i = 0; i < arraysize(orders); i++) {
ByteBuffer buffer(orders[i]);
ByteBufferWriter buffer(orders[i]);
EXPECT_EQ(orders[i], buffer.Order());
ByteBufferReader read_buf(nullptr, 0, orders[i]);
EXPECT_EQ(orders[i], read_buf.Order());
uint8_t ru8;
EXPECT_FALSE(buffer.ReadUInt8(&ru8));
EXPECT_FALSE(read_buf.ReadUInt8(&ru8));
// Write and read uint8_t.
uint8_t wu8 = 1;
buffer.WriteUInt8(wu8);
EXPECT_TRUE(buffer.ReadUInt8(&ru8));
ByteBufferReader read_buf1(buffer.Data(), buffer.Length(), orders[i]);
EXPECT_TRUE(read_buf1.ReadUInt8(&ru8));
EXPECT_EQ(wu8, ru8);
EXPECT_EQ(0U, buffer.Length());
EXPECT_EQ(0U, read_buf1.Length());
buffer.Clear();
// Write and read uint16_t.
uint16_t wu16 = (1 << 8) + 1;
buffer.WriteUInt16(wu16);
ByteBufferReader read_buf2(buffer.Data(), buffer.Length(), orders[i]);
uint16_t ru16;
EXPECT_TRUE(buffer.ReadUInt16(&ru16));
EXPECT_TRUE(read_buf2.ReadUInt16(&ru16));
EXPECT_EQ(wu16, ru16);
EXPECT_EQ(0U, buffer.Length());
EXPECT_EQ(0U, read_buf2.Length());
buffer.Clear();
// Write and read uint24.
uint32_t wu24 = (3 << 16) + (2 << 8) + 1;
buffer.WriteUInt24(wu24);
ByteBufferReader read_buf3(buffer.Data(), buffer.Length(), orders[i]);
uint32_t ru24;
EXPECT_TRUE(buffer.ReadUInt24(&ru24));
EXPECT_TRUE(read_buf3.ReadUInt24(&ru24));
EXPECT_EQ(wu24, ru24);
EXPECT_EQ(0U, buffer.Length());
EXPECT_EQ(0U, read_buf3.Length());
buffer.Clear();
// Write and read uint32_t.
uint32_t wu32 = (4 << 24) + (3 << 16) + (2 << 8) + 1;
buffer.WriteUInt32(wu32);
ByteBufferReader read_buf4(buffer.Data(), buffer.Length(), orders[i]);
uint32_t ru32;
EXPECT_TRUE(buffer.ReadUInt32(&ru32));
EXPECT_TRUE(read_buf4.ReadUInt32(&ru32));
EXPECT_EQ(wu32, ru32);
EXPECT_EQ(0U, buffer.Length());
EXPECT_EQ(0U, read_buf3.Length());
buffer.Clear();
// 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);
ByteBufferReader read_buf5(buffer.Data(), buffer.Length(), orders[i]);
uint64_t ru64;
EXPECT_TRUE(buffer.ReadUInt64(&ru64));
EXPECT_TRUE(read_buf5.ReadUInt64(&ru64));
EXPECT_EQ(wu64, ru64);
EXPECT_EQ(0U, buffer.Length());
EXPECT_EQ(0U, read_buf5.Length());
buffer.Clear();
// Write and read string.
std::string write_string("hello");
buffer.WriteString(write_string);
ByteBufferReader read_buf6(buffer.Data(), buffer.Length(), orders[i]);
std::string read_string;
EXPECT_TRUE(buffer.ReadString(&read_string, write_string.size()));
EXPECT_TRUE(read_buf6.ReadString(&read_string, write_string.size()));
EXPECT_EQ(write_string, read_string);
EXPECT_EQ(0U, buffer.Length());
EXPECT_EQ(0U, read_buf6.Length());
buffer.Clear();
// Write and read bytes
char write_bytes[] = "foo";
buffer.WriteBytes(write_bytes, 3);
ByteBufferReader read_buf7(buffer.Data(), buffer.Length(), orders[i]);
char read_bytes[3];
EXPECT_TRUE(buffer.ReadBytes(read_bytes, 3));
EXPECT_TRUE(read_buf7.ReadBytes(read_bytes, 3));
for (int i = 0; i < 3; ++i) {
EXPECT_EQ(write_bytes[i], read_bytes[i]);
}
EXPECT_EQ(0U, buffer.Length());
EXPECT_EQ(0U, read_buf7.Length());
buffer.Clear();
// Write and read reserved buffer space
char* write_dst = buffer.ReserveWriteBuffer(3);
memcpy(write_dst, write_bytes, 3);
ByteBufferReader read_buf8(buffer.Data(), buffer.Length(), orders[i]);
memset(read_bytes, 0, 3);
EXPECT_TRUE(buffer.ReadBytes(read_bytes, 3));
EXPECT_TRUE(read_buf8.ReadBytes(read_bytes, 3));
for (int i = 0; i < 3; ++i) {
EXPECT_EQ(write_bytes[i], read_bytes[i]);
}
EXPECT_EQ(0U, buffer.Length());
EXPECT_EQ(0U, read_buf8.Length());
buffer.Clear();
// Write and read in order.
buffer.WriteUInt8(wu8);
@ -195,17 +180,19 @@ TEST(ByteBufferTest, TestReadWriteBuffer) {
buffer.WriteUInt24(wu24);
buffer.WriteUInt32(wu32);
buffer.WriteUInt64(wu64);
EXPECT_TRUE(buffer.ReadUInt8(&ru8));
ByteBufferReader read_buf9(buffer.Data(), buffer.Length(), orders[i]);
EXPECT_TRUE(read_buf9.ReadUInt8(&ru8));
EXPECT_EQ(wu8, ru8);
EXPECT_TRUE(buffer.ReadUInt16(&ru16));
EXPECT_TRUE(read_buf9.ReadUInt16(&ru16));
EXPECT_EQ(wu16, ru16);
EXPECT_TRUE(buffer.ReadUInt24(&ru24));
EXPECT_TRUE(read_buf9.ReadUInt24(&ru24));
EXPECT_EQ(wu24, ru24);
EXPECT_TRUE(buffer.ReadUInt32(&ru32));
EXPECT_TRUE(read_buf9.ReadUInt32(&ru32));
EXPECT_EQ(wu32, ru32);
EXPECT_TRUE(buffer.ReadUInt64(&ru64));
EXPECT_TRUE(read_buf9.ReadUInt64(&ru64));
EXPECT_EQ(wu64, ru64);
EXPECT_EQ(0U, buffer.Length());
EXPECT_EQ(0U, read_buf9.Length());
buffer.Clear();
}
}

28
webrtc/base/socketadapters.cc
View File

@ -561,7 +561,7 @@ void AsyncSocksProxySocket::OnConnectEvent(AsyncSocket* socket) {
void AsyncSocksProxySocket::ProcessInput(char* data, size_t* len) {
ASSERT(state_ < SS_TUNNEL);
ByteBuffer response(data, *len);
ByteBufferReader response(data, *len);
if (state_ == SS_HELLO) {
uint8_t ver, method;
@ -638,7 +638,7 @@ void AsyncSocksProxySocket::ProcessInput(char* data, size_t* len) {
// Consume parsed data
*len = response.Length();
memcpy(data, response.Data(), *len);
memmove(data, response.Data(), *len);
if (state_ != SS_TUNNEL)
return;
@ -653,7 +653,7 @@ void AsyncSocksProxySocket::ProcessInput(char* data, size_t* len) {
}
void AsyncSocksProxySocket::SendHello() {
ByteBuffer request;
ByteBufferWriter request;
request.WriteUInt8(5); // Socks Version
if (user_.empty()) {
request.WriteUInt8(1); // Authentication Mechanisms
@ -668,7 +668,7 @@ void AsyncSocksProxySocket::SendHello() {
}
void AsyncSocksProxySocket::SendAuth() {
ByteBuffer request;
ByteBufferWriter request;
request.WriteUInt8(1); // Negotiation Version
request.WriteUInt8(static_cast<uint8_t>(user_.size()));
request.WriteString(user_); // Username
@ -684,7 +684,7 @@ void AsyncSocksProxySocket::SendAuth() {
}
void AsyncSocksProxySocket::SendConnect() {
ByteBuffer request;
ByteBufferWriter request;
request.WriteUInt8(5); // Socks Version
request.WriteUInt8(1); // CONNECT
request.WriteUInt8(0); // Reserved
@ -719,7 +719,7 @@ void AsyncSocksProxyServerSocket::ProcessInput(char* data, size_t* len) {
// TODO: See if the whole message has arrived
ASSERT(state_ < SS_CONNECT_PENDING);
ByteBuffer response(data, *len);
ByteBufferReader response(data, *len);
if (state_ == SS_HELLO) {
HandleHello(&response);
} else if (state_ == SS_AUTH) {
@ -730,14 +730,14 @@ void AsyncSocksProxyServerSocket::ProcessInput(char* data, size_t* len) {
// Consume parsed data
*len = response.Length();
memcpy(data, response.Data(), *len);
memmove(data, response.Data(), *len);
}
void AsyncSocksProxyServerSocket::DirectSend(const ByteBuffer& buf) {
void AsyncSocksProxyServerSocket::DirectSend(const ByteBufferWriter& buf) {
BufferedReadAdapter::DirectSend(buf.Data(), buf.Length());
}
void AsyncSocksProxyServerSocket::HandleHello(ByteBuffer* request) {
void AsyncSocksProxyServerSocket::HandleHello(ByteBufferReader* request) {
uint8_t ver, num_methods;
if (!request->ReadUInt8(&ver) ||
!request->ReadUInt8(&num_methods)) {
@ -769,13 +769,13 @@ void AsyncSocksProxyServerSocket::HandleHello(ByteBuffer* request) {
}
void AsyncSocksProxyServerSocket::SendHelloReply(uint8_t method) {
ByteBuffer response;
ByteBufferWriter response;
response.WriteUInt8(5); // Socks Version
response.WriteUInt8(method); // Auth method
DirectSend(response);
}
void AsyncSocksProxyServerSocket::HandleAuth(ByteBuffer* request) {
void AsyncSocksProxyServerSocket::HandleAuth(ByteBufferReader* request) {
uint8_t ver, user_len, pass_len;
std::string user, pass;
if (!request->ReadUInt8(&ver) ||
@ -793,13 +793,13 @@ void AsyncSocksProxyServerSocket::HandleAuth(ByteBuffer* request) {
}
void AsyncSocksProxyServerSocket::SendAuthReply(uint8_t result) {
ByteBuffer response;
ByteBufferWriter response;
response.WriteUInt8(1); // Negotiation Version
response.WriteUInt8(result);
DirectSend(response);
}
void AsyncSocksProxyServerSocket::HandleConnect(ByteBuffer* request) {
void AsyncSocksProxyServerSocket::HandleConnect(ByteBufferReader* request) {
uint8_t ver, command, reserved, addr_type;
uint32_t ip;
uint16_t port;
@ -828,7 +828,7 @@ void AsyncSocksProxyServerSocket::SendConnectResult(int result,
if (state_ != SS_CONNECT_PENDING)
return;
ByteBuffer response;
ByteBufferWriter response;
response.WriteUInt8(5); // Socks version
response.WriteUInt8((result != 0)); // 0x01 is generic error
response.WriteUInt8(0); // reserved

11
webrtc/base/socketadapters.h
View File

@ -21,7 +21,8 @@
namespace rtc {
struct HttpAuthContext;
class ByteBuffer;
class ByteBufferReader;
class ByteBufferWriter;
///////////////////////////////////////////////////////////////////////////////
@ -193,13 +194,13 @@ class AsyncSocksProxyServerSocket : public AsyncProxyServerSocket {
private:
void ProcessInput(char* data, size_t* len) override;
void DirectSend(const ByteBuffer& buf);
void DirectSend(const ByteBufferWriter& buf);
void HandleHello(ByteBuffer* request);
void HandleHello(ByteBufferReader* request);
void SendHelloReply(uint8_t method);
void HandleAuth(ByteBuffer* request);
void HandleAuth(ByteBufferReader* request);
void SendAuthReply(uint8_t result);
void HandleConnect(ByteBuffer* request);
void HandleConnect(ByteBufferReader* request);
void SendConnectResult(int result, const SocketAddress& addr) override;
void Error(int error);

20
webrtc/libjingle/xmpp/xmppsocket.cc
View File

@ -77,10 +77,13 @@ void XmppSocket::OnReadEvent(rtc::AsyncSocket * socket) {
void XmppSocket::OnWriteEvent(rtc::AsyncSocket * socket) {
// Write bytes if there are any
while (buffer_.Length() != 0) {
int written = cricket_socket_->Send(buffer_.Data(), buffer_.Length());
while (buffer_.size() > 0) {
int written = cricket_socket_->Send(buffer_.data(), buffer_.size());
if (written > 0) {
buffer_.Consume(written);
ASSERT(static_cast<size_t>(written) <= buffer_.size());
memmove(buffer_.data(), buffer_.data() + written,
buffer_.size() - written);
buffer_.SetSize(buffer_.size() - written);
continue;
}
if (!cricket_socket_->IsBlocking())
@ -127,11 +130,11 @@ void XmppSocket::OnEvent(rtc::StreamInterface* stream,
SignalRead();
if ((events & rtc::SE_WRITE)) {
// Write bytes if there are any
while (buffer_.Length() != 0) {
while (buffer_.size() > 0) {
rtc::StreamResult result;
size_t written;
int error;
result = stream_->Write(buffer_.Data(), buffer_.Length(),
result = stream_->Write(buffer_.data(), buffer_.size(),
&written, &error);
if (result == rtc::SR_ERROR) {
LOG(LS_ERROR) << "Send error: " << error;
@ -141,7 +144,10 @@ void XmppSocket::OnEvent(rtc::StreamInterface* stream,
return;
ASSERT(result == rtc::SR_SUCCESS);
ASSERT(written > 0);
buffer_.Shift(written);
ASSERT(written <= buffer_.size());
memmove(buffer_.data(), buffer_.data() + written,
buffer_.size() - written);
buffer_.SetSize(buffer_.size() - written);
}
}
if ((events & rtc::SE_CLOSE))
@ -187,7 +193,7 @@ bool XmppSocket::Read(char * data, size_t len, size_t* len_read) {
}
bool XmppSocket::Write(const char * data, size_t len) {
buffer_.WriteBytes(data, len);
buffer_.AppendData(data, len);
#ifndef USE_SSLSTREAM
OnWriteEvent(cricket_socket_);
#else // USE_SSLSTREAM

4
webrtc/libjingle/xmpp/xmppsocket.h
View File

@ -14,7 +14,7 @@
#include "webrtc/libjingle/xmpp/asyncsocket.h"
#include "webrtc/libjingle/xmpp/xmppengine.h"
#include "webrtc/base/asyncsocket.h"
#include "webrtc/base/bytebuffer.h"
#include "webrtc/base/buffer.h"
#include "webrtc/base/sigslot.h"
// The below define selects the SSLStreamAdapter implementation for
@ -62,7 +62,7 @@ private:
rtc::StreamInterface *stream_;
#endif // USE_SSLSTREAM
buzz::AsyncSocket::State state_;
rtc::ByteBuffer buffer_;
rtc::Buffer buffer_;
buzz::TlsOptions tls_;
};

12
webrtc/media/base/rtpdump.cc
View File

@ -36,7 +36,7 @@ RtpDumpFileHeader::RtpDumpFileHeader(uint32_t start_ms, uint32_t s, uint16_t p)
padding(0) {
}
void RtpDumpFileHeader::WriteToByteBuffer(rtc::ByteBuffer* buf) {
void RtpDumpFileHeader::WriteToByteBuffer(rtc::ByteBufferWriter* buf) {
buf->WriteUInt32(start_sec);
buf->WriteUInt32(start_usec);
buf->WriteUInt32(source);
@ -113,7 +113,7 @@ rtc::StreamResult RtpDumpReader::ReadPacket(RtpDumpPacket* packet) {
if (res != rtc::SR_SUCCESS) {
return res;
}
rtc::ByteBuffer buf(header, sizeof(header));
rtc::ByteBufferReader buf(header, sizeof(header));
uint16_t dump_packet_len;
uint16_t data_len;
// Read the full length of the rtpdump packet, including the rtpdump header.
@ -157,7 +157,7 @@ rtc::StreamResult RtpDumpReader::ReadFileHeader() {
char header[RtpDumpFileHeader::kHeaderLength];
res = stream_->ReadAll(header, sizeof(header), NULL, NULL);
if (res == rtc::SR_SUCCESS) {
rtc::ByteBuffer buf(header, sizeof(header));
rtc::ByteBufferReader buf(header, sizeof(header));
uint32_t start_sec;
uint32_t start_usec;
buf.ReadUInt32(&start_sec);
@ -290,7 +290,7 @@ void RtpDumpLoopReader::UpdateDumpPacket(RtpDumpPacket* packet) {
sequence += loop_count_ * rtp_seq_num_increase_;
timestamp += loop_count_ * rtp_timestamp_increase_;
// Write the updated sequence number and timestamp back to the RTP packet.
rtc::ByteBuffer buffer;
rtc::ByteBufferWriter buffer;
buffer.WriteUInt16(sequence);
buffer.WriteUInt32(timestamp);
memcpy(&packet->data[2], buffer.Data(), buffer.Length());
@ -326,7 +326,7 @@ rtc::StreamResult RtpDumpWriter::WriteFileHeader() {
return res;
}
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
RtpDumpFileHeader file_header(rtc::Time(), 0, 0);
file_header.WriteToByteBuffer(&buf);
return WriteToStream(buf.Data(), buf.Length());
@ -355,7 +355,7 @@ rtc::StreamResult RtpDumpWriter::WritePacket(const void* data,
}
// Write the dump packet header.
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
buf.WriteUInt16(
static_cast<uint16_t>(RtpDumpPacket::kHeaderLength + write_len));
buf.WriteUInt16(static_cast<uint16_t>(rtcp ? 0 : data_len));

2
webrtc/media/base/rtpdump.h
View File

@ -40,7 +40,7 @@ enum RtpDumpPacketFilter {
struct RtpDumpFileHeader {
RtpDumpFileHeader(uint32_t start_ms, uint32_t s, uint16_t p);
void WriteToByteBuffer(rtc::ByteBuffer* buf);
void WriteToByteBuffer(rtc::ByteBufferWriter* buf);
static const char kFirstLine[];
static const size_t kHeaderLength = 16;

4
webrtc/media/base/rtpdump_unittest.cc
View File

@ -24,7 +24,7 @@ static const uint32_t kTestSsrc = 1;
// Test that we read the correct header fields from the RTP/RTCP packet.
TEST(RtpDumpTest, ReadRtpDumpPacket) {
rtc::ByteBuffer rtp_buf;
rtc::ByteBufferWriter rtp_buf;
RtpTestUtility::kTestRawRtpPackets[0].WriteToByteBuffer(kTestSsrc, &rtp_buf);
RtpDumpPacket rtp_packet(rtp_buf.Data(), rtp_buf.Length(), 0, false);
@ -46,7 +46,7 @@ TEST(RtpDumpTest, ReadRtpDumpPacket) {
EXPECT_EQ(kTestSsrc, ssrc);
EXPECT_FALSE(rtp_packet.GetRtcpType(&rtcp_type));
rtc::ByteBuffer rtcp_buf;
rtc::ByteBufferWriter rtcp_buf;
RtpTestUtility::kTestRawRtcpPackets[0].WriteToByteBuffer(&rtcp_buf);
RtpDumpPacket rtcp_packet(rtcp_buf.Data(), rtcp_buf.Length(), 0, true);

14
webrtc/media/base/testutils.cc
View File

@ -32,7 +32,7 @@ namespace cricket {
// Implementation of RawRtpPacket
/////////////////////////////////////////////////////////////////////////
void RawRtpPacket::WriteToByteBuffer(uint32_t in_ssrc,
rtc::ByteBuffer* buf) const {
rtc::ByteBufferWriter* buf) const {
if (!buf) return;
buf->WriteUInt8(ver_to_cc);
@ -43,7 +43,7 @@ void RawRtpPacket::WriteToByteBuffer(uint32_t in_ssrc,
buf->WriteBytes(payload, sizeof(payload));
}
bool RawRtpPacket::ReadFromByteBuffer(rtc::ByteBuffer* buf) {
bool RawRtpPacket::ReadFromByteBuffer(rtc::ByteBufferReader* buf) {
if (!buf) return false;
bool ret = true;
@ -71,7 +71,7 @@ bool RawRtpPacket::SameExceptSeqNumTimestampSsrc(const RawRtpPacket& packet,
/////////////////////////////////////////////////////////////////////////
// Implementation of RawRtcpPacket
/////////////////////////////////////////////////////////////////////////
void RawRtcpPacket::WriteToByteBuffer(rtc::ByteBuffer *buf) const {
void RawRtcpPacket::WriteToByteBuffer(rtc::ByteBufferWriter *buf) const {
if (!buf) return;
buf->WriteUInt8(ver_to_count);
@ -80,7 +80,7 @@ void RawRtcpPacket::WriteToByteBuffer(rtc::ByteBuffer *buf) const {
buf->WriteBytes(payload, sizeof(payload));
}
bool RawRtcpPacket::ReadFromByteBuffer(rtc::ByteBuffer* buf) {
bool RawRtcpPacket::ReadFromByteBuffer(rtc::ByteBufferReader* buf) {
if (!buf) return false;
bool ret = true;
@ -129,7 +129,7 @@ bool RtpTestUtility::WriteTestPackets(size_t count,
bool result = true;
uint32_t elapsed_time_ms = 0;
for (size_t i = 0; i < count && result; ++i) {
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
if (rtcp) {
kTestRawRtcpPackets[i].WriteToByteBuffer(&buf);
} else {
@ -164,7 +164,7 @@ bool RtpTestUtility::VerifyTestPacketsFromStream(size_t count,
prev_elapsed_time = packet.elapsed_time;
// Check the RTP or RTCP packet.
rtc::ByteBuffer buf(reinterpret_cast<const char*>(&packet.data[0]),
rtc::ByteBufferReader buf(reinterpret_cast<const char*>(&packet.data[0]),
packet.data.size());
if (packet.is_rtcp()) {
// RTCP packet.
@ -194,7 +194,7 @@ bool RtpTestUtility::VerifyPacket(const RtpDumpPacket* dump,
bool header_only) {
if (!dump || !raw) return false;
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
raw->WriteToByteBuffer(RtpTestUtility::kDefaultSsrc, &buf);
if (header_only) {

11
webrtc/media/base/testutils.h
View File

@ -24,7 +24,8 @@
#include "webrtc/media/base/videocommon.h"
namespace rtc {
class ByteBuffer;
class ByteBufferReader;
class ByteBufferWriter;
class StreamInterface;
}
@ -45,8 +46,8 @@ class RtpDumpWriter;
class VideoFrame;
struct RawRtpPacket {
void WriteToByteBuffer(uint32_t in_ssrc, rtc::ByteBuffer* buf) const;
bool ReadFromByteBuffer(rtc::ByteBuffer* buf);
void WriteToByteBuffer(uint32_t in_ssrc, rtc::ByteBufferWriter* buf) const;
bool ReadFromByteBuffer(rtc::ByteBufferReader* buf);
// Check if this packet is the same as the specified packet except the
// sequence number and timestamp, which should be the same as the specified
// parameters.
@ -65,8 +66,8 @@ struct RawRtpPacket {
};
struct RawRtcpPacket {
void WriteToByteBuffer(rtc::ByteBuffer* buf) const;
bool ReadFromByteBuffer(rtc::ByteBuffer* buf);
void WriteToByteBuffer(rtc::ByteBufferWriter* buf) const;
bool ReadFromByteBuffer(rtc::ByteBufferReader* buf);
bool EqualsTo(const RawRtcpPacket& packet) const;
uint8_t ver_to_count;

6
webrtc/media/base/videoengine_unittest.h
View File

@ -279,8 +279,7 @@ class VideoMediaChannelTest : public testing::Test,
uint32_t* tstamp,
uint32_t* ssrc,
std::string* payload) {
// TODO(jbauch): avoid copying the buffer data into the ByteBuffer
rtc::ByteBuffer buf(p->data<char>(), p->size());
rtc::ByteBufferReader buf(p->data<char>(), p->size());
uint8_t u08 = 0;
uint16_t u16 = 0;
uint32_t u32 = 0;
@ -340,8 +339,7 @@ class VideoMediaChannelTest : public testing::Test,
int count = 0;
for (int i = start_index; i < stop_index; ++i) {
std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtcpPacket(i));
// TODO(jbauch): avoid copying the buffer data into the ByteBuffer
rtc::ByteBuffer buf(p->data<char>(), p->size());
rtc::ByteBufferReader buf(p->data<char>(), p->size());
size_t total_len = 0;
// The packet may be a compound RTCP packet.
while (total_len < p->size()) {

10
webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.cc
View File

@ -68,9 +68,9 @@ std::vector<size_t> FindNaluStartSequences(const uint8_t* buffer,
// TODO(pbos): Make parsing RBSP something that can be integrated into BitBuffer
// so we don't have to copy the entire frames when only interested in the
// headers.
rtc::ByteBuffer* ParseRbsp(const uint8_t* bytes, size_t length) {
rtc::ByteBufferWriter* ParseRbsp(const uint8_t* bytes, size_t length) {
// Copied from webrtc::H264SpsParser::Parse.
rtc::ByteBuffer* rbsp_buffer = new rtc::ByteBuffer;
rtc::ByteBufferWriter* rbsp_buffer = new rtc::ByteBufferWriter();
for (size_t i = 0; i < length;) {
if (length - i >= 3 && bytes[i] == 0 && bytes[i + 1] == 0 &&
bytes[i + 2] == 3) {
@ -103,7 +103,7 @@ bool H264BitstreamParser::ParseSpsNalu(const uint8_t* sps, size_t length) {
sps_parsed_ = false;
// Parse out the SPS RBSP. It should be small, so it's ok that we create a
// copy. We'll eventually write this back.
rtc::scoped_ptr<rtc::ByteBuffer> sps_rbsp(
rtc::scoped_ptr<rtc::ByteBufferWriter> sps_rbsp(
ParseRbsp(sps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize));
rtc::BitBuffer sps_parser(reinterpret_cast<const uint8_t*>(sps_rbsp->Data()),
sps_rbsp->Length());
@ -209,7 +209,7 @@ bool H264BitstreamParser::ParsePpsNalu(const uint8_t* pps, size_t length) {
// We're starting a new stream, so reset picture type rewriting values.
pps_ = PpsState();
pps_parsed_ = false;
rtc::scoped_ptr<rtc::ByteBuffer> buffer(
rtc::scoped_ptr<rtc::ByteBufferWriter> buffer(
ParseRbsp(pps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize));
rtc::BitBuffer parser(reinterpret_cast<const uint8_t*>(buffer->Data()),
buffer->Length());
@ -317,7 +317,7 @@ bool H264BitstreamParser::ParseNonParameterSetNalu(const uint8_t* source,
RTC_CHECK(sps_parsed_);
RTC_CHECK(pps_parsed_);
last_slice_qp_delta_parsed_ = false;
rtc::scoped_ptr<rtc::ByteBuffer> slice_rbsp(ParseRbsp(
rtc::scoped_ptr<rtc::ByteBufferWriter> slice_rbsp(ParseRbsp(
source + kNaluHeaderAndTypeSize, source_length - kNaluHeaderAndTypeSize));
rtc::BitBuffer slice_reader(
reinterpret_cast<const uint8_t*>(slice_rbsp->Data()),

2
webrtc/modules/rtp_rtcp/source/h264_sps_parser.cc
View File

@ -34,7 +34,7 @@ bool H264SpsParser::Parse() {
// First, parse out rbsp, which is basically the source buffer minus emulation
// bytes (the last byte of a 0x00 0x00 0x03 sequence). RBSP is defined in
// section 7.3.1 of the H.264 standard.
rtc::ByteBuffer rbsp_buffer;
rtc::ByteBufferWriter rbsp_buffer;
for (size_t i = 0; i < byte_length_;) {
// Be careful about over/underflow here. byte_length_ - 3 can underflow, and
// i + 3 can overflow, but byte_length_ - i can't, because i < byte_length_

6
webrtc/p2p/base/port.cc
View File

@ -343,7 +343,7 @@ bool Port::GetStunMessage(const char* data,
// Parse the request message. If the packet is not a complete and correct
// STUN message, then ignore it.
rtc::scoped_ptr<IceMessage> stun_msg(new IceMessage());
rtc::ByteBuffer buf(data, size);
rtc::ByteBufferReader buf(data, size);
if (!stun_msg->Read(&buf) || (buf.Length() > 0)) {
return false;
}
@ -565,7 +565,7 @@ void Port::SendBindingResponse(StunMessage* request,
response.AddFingerprint();
// Send the response message.
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
response.Write(&buf);
rtc::PacketOptions options(DefaultDscpValue());
auto err = SendTo(buf.Data(), buf.Length(), addr, options, false);
@ -613,7 +613,7 @@ void Port::SendBindingErrorResponse(StunMessage* request,
response.AddFingerprint();
// Send the response message.
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
response.Write(&buf);
rtc::PacketOptions options(DefaultDscpValue());
SendTo(buf.Data(), buf.Length(), addr, options, false);

63
webrtc/p2p/base/port_unittest.cc
View File

@ -18,6 +18,7 @@
#include "webrtc/p2p/base/transport.h"
#include "webrtc/p2p/base/turnport.h"
#include "webrtc/base/arraysize.h"
#include "webrtc/base/buffer.h"
#include "webrtc/base/crc32.h"
#include "webrtc/base/gunit.h"
#include "webrtc/base/helpers.h"
@ -33,7 +34,9 @@
#include "webrtc/base/virtualsocketserver.h"
using rtc::AsyncPacketSocket;
using rtc::ByteBuffer;
using rtc::Buffer;
using rtc::ByteBufferReader;
using rtc::ByteBufferWriter;
using rtc::NATType;
using rtc::NAT_OPEN_CONE;
using rtc::NAT_ADDR_RESTRICTED;
@ -84,13 +87,14 @@ static SocketAddress GetAddress(Port* port) {
static IceMessage* CopyStunMessage(const IceMessage* src) {
IceMessage* dst = new IceMessage();
ByteBuffer buf;
ByteBufferWriter buf;
src->Write(&buf);
dst->Read(&buf);
ByteBufferReader read_buf(buf);
dst->Read(&read_buf);
return dst;
}
static bool WriteStunMessage(const StunMessage* msg, ByteBuffer* buf) {
static bool WriteStunMessage(const StunMessage* msg, ByteBufferWriter* buf) {
buf->Resize(0); // clear out any existing buffer contents
return msg->Write(buf);
}
@ -123,7 +127,7 @@ class TestPort : public Port {
// The last StunMessage that was sent on this Port.
// TODO: Make these const; requires changes to SendXXXXResponse.
ByteBuffer* last_stun_buf() { return last_stun_buf_.get(); }
Buffer* last_stun_buf() { return last_stun_buf_.get(); }
IceMessage* last_stun_msg() { return last_stun_msg_.get(); }
int last_stun_error_code() {
int code = 0;
@ -174,14 +178,13 @@ class TestPort : public Port {
const rtc::PacketOptions& options, bool payload) {
if (!payload) {
IceMessage* msg = new IceMessage;
ByteBuffer* buf = new ByteBuffer(static_cast<const char*>(data), size);
ByteBuffer::ReadPosition pos(buf->GetReadPosition());
if (!msg->Read(buf)) {
Buffer* buf = new Buffer(static_cast<const char*>(data), size);
ByteBufferReader read_buf(*buf);
if (!msg->Read(&read_buf)) {
delete msg;
delete buf;
return -1;
}
buf->SetReadPosition(pos);
last_stun_buf_.reset(buf);
last_stun_msg_.reset(msg);
}
@ -209,7 +212,7 @@ class TestPort : public Port {
const rtc::SentPacket& sent_packet) {
PortInterface::SignalSentPacket(sent_packet);
}
rtc::scoped_ptr<ByteBuffer> last_stun_buf_;
rtc::scoped_ptr<Buffer> last_stun_buf_;
rtc::scoped_ptr<IceMessage> last_stun_msg_;
int type_preference_ = 0;
};
@ -1332,8 +1335,8 @@ TEST_F(PortTest, TestLoopbackCal) {
ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
IceMessage* msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
conn->OnReadPacket(lport->last_stun_buf()->Data(),
lport->last_stun_buf()->Length(),
conn->OnReadPacket(lport->last_stun_buf()->data<char>(),
lport->last_stun_buf()->size(),
rtc::PacketTime());
ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
msg = lport->last_stun_msg();
@ -1365,7 +1368,7 @@ TEST_F(PortTest, TestLoopbackCal) {
modified_req->AddFingerprint();
lport->Reset();
rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
WriteStunMessage(modified_req.get(), buf.get());
conn1->OnReadPacket(buf->Data(), buf->Length(), rtc::PacketTime());
ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
@ -1402,8 +1405,8 @@ TEST_F(PortTest, TestIceRoleConflict) {
IceMessage* msg = rport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
// Send rport binding request to lport.
lconn->OnReadPacket(rport->last_stun_buf()->Data(),
rport->last_stun_buf()->Length(),
lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
rport->last_stun_buf()->size(),
rtc::PacketTime());
ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
@ -1628,7 +1631,7 @@ TEST_F(PortTest, TestSendStunMessage) {
EXPECT_EQ("rfrag:lfrag", username_attr->GetString());
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL);
EXPECT_TRUE(StunMessage::ValidateMessageIntegrity(
lport->last_stun_buf()->Data(), lport->last_stun_buf()->Length(),
lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size(),
"rpass"));
const StunUInt64Attribute* ice_controlling_attr =
msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING);
@ -1638,7 +1641,7 @@ TEST_F(PortTest, TestSendStunMessage) {
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != NULL);
EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
EXPECT_TRUE(StunMessage::ValidateFingerprint(
lport->last_stun_buf()->Data(), lport->last_stun_buf()->Length()));
lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size()));
// Request should not include ping count.
ASSERT_TRUE(msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT) == NULL);
@ -1660,11 +1663,11 @@ TEST_F(PortTest, TestSendStunMessage) {
EXPECT_EQ(lport->Candidates()[0].address(), addr_attr->GetAddress());
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL);
EXPECT_TRUE(StunMessage::ValidateMessageIntegrity(
rport->last_stun_buf()->Data(), rport->last_stun_buf()->Length(),
rport->last_stun_buf()->data<char>(), rport->last_stun_buf()->size(),
"rpass"));
EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
EXPECT_TRUE(StunMessage::ValidateFingerprint(
lport->last_stun_buf()->Data(), lport->last_stun_buf()->Length()));
lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size()));
// No USERNAME or PRIORITY in ICE responses.
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USERNAME) == NULL);
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == NULL);
@ -1692,11 +1695,11 @@ TEST_F(PortTest, TestSendStunMessage) {
EXPECT_EQ(std::string(STUN_ERROR_REASON_SERVER_ERROR), error_attr->reason());
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL);
EXPECT_TRUE(StunMessage::ValidateMessageIntegrity(
rport->last_stun_buf()->Data(), rport->last_stun_buf()->Length(),
rport->last_stun_buf()->data<char>(), rport->last_stun_buf()->size(),
"rpass"));
EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
EXPECT_TRUE(StunMessage::ValidateFingerprint(
lport->last_stun_buf()->Data(), lport->last_stun_buf()->Length()));
lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size()));
// No USERNAME with ICE.
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USERNAME) == NULL);
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == NULL);
@ -1813,7 +1816,7 @@ TEST_F(PortTest, TestHandleStunMessage) {
CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
rtc::scoped_ptr<IceMessage> in_msg, out_msg;
rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
rtc::SocketAddress addr(kLocalAddr1);
std::string username;
@ -1863,7 +1866,7 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {
CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
rtc::scoped_ptr<IceMessage> in_msg, out_msg;
rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
rtc::SocketAddress addr(kLocalAddr1);
std::string username;
@ -1932,7 +1935,7 @@ TEST_F(PortTest, TestHandleStunMessageBadMessageIntegrity) {
CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
rtc::scoped_ptr<IceMessage> in_msg, out_msg;
rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
rtc::SocketAddress addr(kLocalAddr1);
std::string username;
@ -1973,7 +1976,7 @@ TEST_F(PortTest, TestHandleStunMessageBadFingerprint) {
CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
rtc::scoped_ptr<IceMessage> in_msg, out_msg;
rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
rtc::SocketAddress addr(kLocalAddr1);
std::string username;
@ -2042,7 +2045,7 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
// Verifying encoding and decoding STUN indication message.
rtc::scoped_ptr<IceMessage> in_msg, out_msg;
rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
rtc::SocketAddress addr(kLocalAddr1);
std::string username;
@ -2077,8 +2080,8 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
IceMessage* msg = rport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
// Send rport binding request to lport.
lconn->OnReadPacket(rport->last_stun_buf()->Data(),
rport->last_stun_buf()->Length(),
lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
rport->last_stun_buf()->size(),
rtc::PacketTime());
ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
@ -2464,8 +2467,8 @@ TEST_F(PortTest, TestIceLiteConnectivity) {
request.get(), ice_full_port->Candidates()[0].address());
// Feeding the respone message from litemode to the full mode connection.
ch1.conn()->OnReadPacket(ice_lite_port->last_stun_buf()->Data(),
ice_lite_port->last_stun_buf()->Length(),
ch1.conn()->OnReadPacket(ice_lite_port->last_stun_buf()->data<char>(),
ice_lite_port->last_stun_buf()->size(),
rtc::PacketTime());
// Verifying full mode connection becomes writable from the response.
EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),

4
webrtc/p2p/base/pseudotcp.cc
View File

@ -1168,7 +1168,7 @@ PseudoTcp::disableWindowScale() {
void
PseudoTcp::queueConnectMessage() {
rtc::ByteBuffer buf(rtc::ByteBuffer::ORDER_NETWORK);
rtc::ByteBufferWriter buf(rtc::ByteBuffer::ORDER_NETWORK);
buf.WriteUInt8(CTL_CONNECT);
if (m_support_wnd_scale) {
@ -1185,7 +1185,7 @@ void PseudoTcp::parseOptions(const char* data, uint32_t len) {
// See http://www.freesoft.org/CIE/Course/Section4/8.htm for
// parsing the options list.
rtc::ByteBuffer buf(data, len);
rtc::ByteBufferReader buf(data, len);
while (buf.Length()) {
uint8_t kind = TCP_OPT_EOL;
buf.ReadUInt8(&kind);

4
webrtc/p2p/base/relayport.cc
View File

@ -607,7 +607,7 @@ int RelayEntry::SendTo(const void* data, size_t size,
// TODO: compute the HMAC.
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
request.Write(&buf);
return SendPacket(buf.Data(), buf.Length(), options);
@ -703,7 +703,7 @@ void RelayEntry::OnReadPacket(
return;
}
rtc::ByteBuffer buf(data, size);
rtc::ByteBufferReader buf(data, size);
RelayMessage msg;
if (!msg.Read(&buf)) {
LOG(INFO) << "Incoming packet was not STUN";

6
webrtc/p2p/base/relayserver.cc
View File

@ -46,7 +46,7 @@ void Send(rtc::AsyncPacketSocket* socket, const char* bytes, size_t size,
void SendStun(const StunMessage& msg,
rtc::AsyncPacketSocket* socket,
const rtc::SocketAddress& addr) {
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
msg.Write(&buf);
Send(socket, buf.Data(), buf.Length(), addr);
}
@ -249,7 +249,7 @@ void RelayServer::OnExternalPacket(
// The first packet should always be a STUN / TURN packet. If it isn't, then
// we should just ignore this packet.
RelayMessage msg;
rtc::ByteBuffer buf(bytes, size);
rtc::ByteBufferReader buf(bytes, size);
if (!msg.Read(&buf)) {
LOG(LS_WARNING) << "Dropping packet: first packet not STUN";
return;
@ -298,7 +298,7 @@ bool RelayServer::HandleStun(
StunMessage* msg) {
// Parse this into a stun message. Eat the message if this fails.
rtc::ByteBuffer buf(bytes, size);
rtc::ByteBufferReader buf(bytes, size);
if (!msg->Read(&buf)) {
return false;
}

11
webrtc/p2p/base/relayserver_unittest.cc
View File

@ -76,12 +76,12 @@ class RelayServerTest : public testing::Test {
}
void Send1(const StunMessage* msg) {
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
msg->Write(&buf);
SendRaw1(buf.Data(), static_cast<int>(buf.Length()));
}
void Send2(const StunMessage* msg) {
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
msg->Write(&buf);
SendRaw2(buf.Data(), static_cast<int>(buf.Length()));
}
@ -120,9 +120,10 @@ class RelayServerTest : public testing::Test {
rtc::TestClient::Packet* packet =
client->NextPacket(rtc::TestClient::kTimeoutMs);
if (packet) {
rtc::ByteBuffer buf(packet->buf, packet->size);
rtc::ByteBufferWriter buf(packet->buf, packet->size);
rtc::ByteBufferReader read_buf(buf);
msg = new RelayMessage();
msg->Read(&buf);
msg->Read(&read_buf);
delete packet;
}
return msg;
@ -302,7 +303,7 @@ TEST_F(RelayServerTest, TestRemoteBind) {
res->GetByteString(STUN_ATTR_DATA);
ASSERT_TRUE(recv_data != NULL);
rtc::ByteBuffer buf(recv_data->bytes(), recv_data->length());
rtc::ByteBufferReader buf(recv_data->bytes(), recv_data->length());
rtc::scoped_ptr<StunMessage> res2(new StunMessage());
EXPECT_TRUE(res2->Read(&buf));
EXPECT_EQ(STUN_BINDING_REQUEST, res2->type());

43
webrtc/p2p/base/stun.cc
View File

@ -20,7 +20,8 @@
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/stringencode.h"
using rtc::ByteBuffer;
using rtc::ByteBufferReader;
using rtc::ByteBufferWriter;
namespace cricket {
@ -219,7 +220,7 @@ bool StunMessage::AddMessageIntegrity(const char* key,
VERIFY(AddAttribute(msg_integrity_attr));
// Calculate the HMAC for the message.
rtc::ByteBuffer buf;
ByteBufferWriter buf;
if (!Write(&buf))
return false;
@ -280,7 +281,7 @@ bool StunMessage::AddFingerprint() {
VERIFY(AddAttribute(fingerprint_attr));
// Calculate the CRC-32 for the message and insert it.
rtc::ByteBuffer buf;
ByteBufferWriter buf;
if (!Write(&buf))
return false;
@ -293,7 +294,7 @@ bool StunMessage::AddFingerprint() {
return true;
}
bool StunMessage::Read(ByteBuffer* buf) {
bool StunMessage::Read(ByteBufferReader* buf) {
if (!buf->ReadUInt16(&type_))
return false;
@ -356,7 +357,7 @@ bool StunMessage::Read(ByteBuffer* buf) {
return true;
}
bool StunMessage::Write(ByteBuffer* buf) const {
bool StunMessage::Write(ByteBufferWriter* buf) const {
buf->WriteUInt16(type_);
buf->WriteUInt16(length_);
if (!IsLegacy())
@ -417,14 +418,14 @@ StunAttribute::StunAttribute(uint16_t type, uint16_t length)
: type_(type), length_(length) {
}
void StunAttribute::ConsumePadding(rtc::ByteBuffer* buf) const {
void StunAttribute::ConsumePadding(ByteBufferReader* buf) const {
int remainder = length_ % 4;
if (remainder > 0) {
buf->Consume(4 - remainder);
}
}
void StunAttribute::WritePadding(rtc::ByteBuffer* buf) const {
void StunAttribute::WritePadding(ByteBufferWriter* buf) const {
int remainder = length_ % 4;
if (remainder > 0) {
char zeroes[4] = {0};
@ -495,7 +496,7 @@ StunAddressAttribute::StunAddressAttribute(uint16_t type, uint16_t length)
: StunAttribute(type, length) {
}
bool StunAddressAttribute::Read(ByteBuffer* buf) {
bool StunAddressAttribute::Read(ByteBufferReader* buf) {
uint8_t dummy;
if (!buf->ReadUInt8(&dummy))
return false;
@ -533,7 +534,7 @@ bool StunAddressAttribute::Read(ByteBuffer* buf) {
return true;
}
bool StunAddressAttribute::Write(ByteBuffer* buf) const {
bool StunAddressAttribute::Write(ByteBufferWriter* buf) const {
StunAddressFamily address_family = family();
if (address_family == STUN_ADDRESS_UNDEF) {
LOG(LS_ERROR) << "Error writing address attribute: unknown family.";
@ -604,7 +605,7 @@ rtc::IPAddress StunXorAddressAttribute::GetXoredIP() const {
return rtc::IPAddress();
}
bool StunXorAddressAttribute::Read(ByteBuffer* buf) {
bool StunXorAddressAttribute::Read(ByteBufferReader* buf) {
if (!StunAddressAttribute::Read(buf))
return false;
uint16_t xoredport = port() ^ (kStunMagicCookie >> 16);
@ -613,7 +614,7 @@ bool StunXorAddressAttribute::Read(ByteBuffer* buf) {
return true;
}
bool StunXorAddressAttribute::Write(ByteBuffer* buf) const {
bool StunXorAddressAttribute::Write(ByteBufferWriter* buf) const {
StunAddressFamily address_family = family();
if (address_family == STUN_ADDRESS_UNDEF) {
LOG(LS_ERROR) << "Error writing xor-address attribute: unknown family.";
@ -660,13 +661,13 @@ void StunUInt32Attribute::SetBit(size_t index, bool value) {
bits_ |= value ? (1 << index) : 0;
}
bool StunUInt32Attribute::Read(ByteBuffer* buf) {
bool StunUInt32Attribute::Read(ByteBufferReader* buf) {
if (length() != SIZE || !buf->ReadUInt32(&bits_))
return false;
return true;
}
bool StunUInt32Attribute::Write(ByteBuffer* buf) const {
bool StunUInt32Attribute::Write(ByteBufferWriter* buf) const {
buf->WriteUInt32(bits_);
return true;
}
@ -679,13 +680,13 @@ StunUInt64Attribute::StunUInt64Attribute(uint16_t type)
: StunAttribute(type, SIZE), bits_(0) {
}
bool StunUInt64Attribute::Read(ByteBuffer* buf) {
bool StunUInt64Attribute::Read(ByteBufferReader* buf) {
if (length() != SIZE || !buf->ReadUInt64(&bits_))
return false;
return true;
}
bool StunUInt64Attribute::Write(ByteBuffer* buf) const {
bool StunUInt64Attribute::Write(ByteBufferWriter* buf) const {
buf->WriteUInt64(bits_);
return true;
}
@ -737,7 +738,7 @@ void StunByteStringAttribute::SetByte(size_t index, uint8_t value) {
bytes_[index] = value;
}
bool StunByteStringAttribute::Read(ByteBuffer* buf) {
bool StunByteStringAttribute::Read(ByteBufferReader* buf) {
bytes_ = new char[length()];
if (!buf->ReadBytes(bytes_, length())) {
return false;
@ -747,7 +748,7 @@ bool StunByteStringAttribute::Read(ByteBuffer* buf) {
return true;
}
bool StunByteStringAttribute::Write(ByteBuffer* buf) const {
bool StunByteStringAttribute::Write(ByteBufferWriter* buf) const {
buf->WriteBytes(bytes_, length());
WritePadding(buf);
return true;
@ -788,7 +789,7 @@ void StunErrorCodeAttribute::SetReason(const std::string& reason) {
reason_ = reason;
}
bool StunErrorCodeAttribute::Read(ByteBuffer* buf) {
bool StunErrorCodeAttribute::Read(ByteBufferReader* buf) {
uint32_t val;
if (length() < MIN_SIZE || !buf->ReadUInt32(&val))
return false;
@ -806,7 +807,7 @@ bool StunErrorCodeAttribute::Read(ByteBuffer* buf) {
return true;
}
bool StunErrorCodeAttribute::Write(ByteBuffer* buf) const {
bool StunErrorCodeAttribute::Write(ByteBufferWriter* buf) const {
buf->WriteUInt32(class_ << 8 | number_);
buf->WriteString(reason_);
WritePadding(buf);
@ -839,7 +840,7 @@ void StunUInt16ListAttribute::AddType(uint16_t value) {
SetLength(static_cast<uint16_t>(attr_types_->size() * 2));
}
bool StunUInt16ListAttribute::Read(ByteBuffer* buf) {
bool StunUInt16ListAttribute::Read(ByteBufferReader* buf) {
if (length() % 2)
return false;
@ -858,7 +859,7 @@ bool StunUInt16ListAttribute::Read(ByteBuffer* buf) {
return true;
}
bool StunUInt16ListAttribute::Write(ByteBuffer* buf) const {
bool StunUInt16ListAttribute::Write(ByteBufferWriter* buf) const {
for (size_t i = 0; i < attr_types_->size(); ++i) {
buf->WriteUInt16((*attr_types_)[i]);
}

40
webrtc/p2p/base/stun.h
View File

@ -180,11 +180,11 @@ class StunMessage {
// Parses the STUN packet in the given buffer and records it here. The
// return value indicates whether this was successful.
bool Read(rtc::ByteBuffer* buf);
bool Read(rtc::ByteBufferReader* buf);
// Writes this object into a STUN packet. The return value indicates whether
// this was successful.
bool Write(rtc::ByteBuffer* buf) const;
bool Write(rtc::ByteBufferWriter* buf) const;
// Creates an empty message. Overridable by derived classes.
virtual StunMessage* CreateNew() const { return new StunMessage(); }
@ -221,11 +221,11 @@ class StunAttribute {
// Reads the body (not the type or length) for this type of attribute from
// the given buffer. Return value is true if successful.
virtual bool Read(rtc::ByteBuffer* buf) = 0;
virtual bool Read(rtc::ByteBufferReader* buf) = 0;
// Writes the body (not the type or length) to the given buffer. Return
// value is true if successful.
virtual bool Write(rtc::ByteBuffer* buf) const = 0;
virtual bool Write(rtc::ByteBufferWriter* buf) const = 0;
// Creates an attribute object with the given type and smallest length.
static StunAttribute* Create(StunAttributeValueType value_type,
@ -245,8 +245,8 @@ class StunAttribute {
protected:
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;
void WritePadding(rtc::ByteBufferWriter* buf) const;
void ConsumePadding(rtc::ByteBufferReader* buf) const;
private:
uint16_t type_;
@ -290,8 +290,8 @@ class StunAddressAttribute : public StunAttribute {
}
void SetPort(uint16_t port) { address_.SetPort(port); }
virtual bool Read(rtc::ByteBuffer* buf);
virtual bool Write(rtc::ByteBuffer* buf) const;
virtual bool Read(rtc::ByteBufferReader* buf);
virtual bool Write(rtc::ByteBufferWriter* buf) const;
private:
void EnsureAddressLength() {
@ -327,8 +327,8 @@ class StunXorAddressAttribute : public StunAddressAttribute {
virtual void SetOwner(StunMessage* owner) {
owner_ = owner;
}
virtual bool Read(rtc::ByteBuffer* buf);
virtual bool Write(rtc::ByteBuffer* buf) const;
virtual bool Read(rtc::ByteBufferReader* buf);
virtual bool Write(rtc::ByteBufferWriter* buf) const;
private:
rtc::IPAddress GetXoredIP() const;
@ -352,8 +352,8 @@ class StunUInt32Attribute : public StunAttribute {
bool GetBit(size_t index) const;
void SetBit(size_t index, bool value);
virtual bool Read(rtc::ByteBuffer* buf);
virtual bool Write(rtc::ByteBuffer* buf) const;
virtual bool Read(rtc::ByteBufferReader* buf);
virtual bool Write(rtc::ByteBufferWriter* buf) const;
private:
uint32_t bits_;
@ -372,8 +372,8 @@ class StunUInt64Attribute : public StunAttribute {
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;
virtual bool Read(rtc::ByteBufferReader* buf);
virtual bool Write(rtc::ByteBufferWriter* buf) const;
private:
uint64_t bits_;
@ -401,8 +401,8 @@ class StunByteStringAttribute : public StunAttribute {
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;
virtual bool Read(rtc::ByteBufferReader* buf);
virtual bool Write(rtc::ByteBufferWriter* buf) const;
private:
void SetBytes(char* bytes, size_t length);
@ -434,8 +434,8 @@ class StunErrorCodeAttribute : public StunAttribute {
void SetNumber(uint8_t number) { number_ = number; }
void SetReason(const std::string& reason);
bool Read(rtc::ByteBuffer* buf);
bool Write(rtc::ByteBuffer* buf) const;
bool Read(rtc::ByteBufferReader* buf);
bool Write(rtc::ByteBufferWriter* buf) const;
private:
uint8_t class_;
@ -458,8 +458,8 @@ class StunUInt16ListAttribute : public StunAttribute {
void SetType(int index, uint16_t value);
void AddType(uint16_t value);
bool Read(rtc::ByteBuffer* buf);
bool Write(rtc::ByteBuffer* buf) const;
bool Read(rtc::ByteBufferReader* buf);
bool Write(rtc::ByteBufferWriter* buf) const;
private:
std::vector<uint16_t>* attr_types_;

72
webrtc/p2p/base/stun_unittest.cc
View File

@ -62,7 +62,7 @@ class StunTest : public ::testing::Test {
const unsigned char* testcase,
size_t size) {
const char* input = reinterpret_cast<const char*>(testcase);
rtc::ByteBuffer buf(input, size);
rtc::ByteBufferReader buf(input, size);
if (msg->Read(&buf)) {
// Returns the size the stun message should report itself as being
return (size - 20);
@ -739,22 +739,23 @@ TEST_F(StunTest, SetIPv6XorAddressAttributeOwner) {
// The internal IP address shouldn't change.
ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
rtc::ByteBuffer correct_buf;
rtc::ByteBuffer wrong_buf;
rtc::ByteBufferWriter correct_buf;
rtc::ByteBufferWriter wrong_buf;
EXPECT_TRUE(addr->Write(&correct_buf));
EXPECT_TRUE(addr2.Write(&wrong_buf));
// But when written out, the buffers should look different.
ASSERT_NE(0,
memcmp(correct_buf.Data(), wrong_buf.Data(), wrong_buf.Length()));
// And when reading a known good value, the address should be wrong.
addr2.Read(&correct_buf);
rtc::ByteBufferReader read_buf(correct_buf);
addr2.Read(&read_buf);
ASSERT_NE(addr->ipaddr(), addr2.ipaddr());
addr2.SetIP(addr->ipaddr());
addr2.SetPort(addr->port());
// Try writing with no owner at all, should fail and write nothing.
addr2.SetOwner(NULL);
ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
wrong_buf.Consume(wrong_buf.Length());
wrong_buf.Clear();
EXPECT_FALSE(addr2.Write(&wrong_buf));
ASSERT_EQ(0U, wrong_buf.Length());
}
@ -786,8 +787,8 @@ TEST_F(StunTest, SetIPv4XorAddressAttributeOwner) {
// The internal IP address shouldn't change.
ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
rtc::ByteBuffer correct_buf;
rtc::ByteBuffer wrong_buf;
rtc::ByteBufferWriter correct_buf;
rtc::ByteBufferWriter wrong_buf;
EXPECT_TRUE(addr->Write(&correct_buf));
EXPECT_TRUE(addr2.Write(&wrong_buf));
// The same address data should be written.
@ -795,13 +796,14 @@ TEST_F(StunTest, SetIPv4XorAddressAttributeOwner) {
memcmp(correct_buf.Data(), wrong_buf.Data(), wrong_buf.Length()));
// And an attribute should be able to un-XOR an address belonging to a message
// with a different transaction ID.
EXPECT_TRUE(addr2.Read(&correct_buf));
rtc::ByteBufferReader read_buf(correct_buf);
EXPECT_TRUE(addr2.Read(&read_buf));
ASSERT_EQ(addr->ipaddr(), addr2.ipaddr());
// However, no owner is still an error, should fail and write nothing.
addr2.SetOwner(NULL);
ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
wrong_buf.Consume(wrong_buf.Length());
wrong_buf.Clear();
EXPECT_FALSE(addr2.Write(&wrong_buf));
}
@ -875,12 +877,13 @@ TEST_F(StunTest, WriteMessageWithIPv6AddressAttribute) {
CheckStunHeader(msg, STUN_BINDING_REQUEST, (size - 20));
rtc::ByteBuffer out;
rtc::ByteBufferWriter out;
EXPECT_TRUE(msg.Write(&out));
ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv6MappedAddress));
int len1 = static_cast<int>(out.Length());
rtc::ByteBufferReader read_buf(out);
std::string bytes;
out.ReadString(&bytes, len1);
read_buf.ReadString(&bytes, len1);
ASSERT_EQ(0, memcmp(bytes.c_str(), kStunMessageWithIPv6MappedAddress, len1));
}
@ -904,12 +907,13 @@ TEST_F(StunTest, WriteMessageWithIPv4AddressAttribute) {
CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
rtc::ByteBuffer out;
rtc::ByteBufferWriter out;
EXPECT_TRUE(msg.Write(&out));
ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv4MappedAddress));
int len1 = static_cast<int>(out.Length());
rtc::ByteBufferReader read_buf(out);
std::string bytes;
out.ReadString(&bytes, len1);
read_buf.ReadString(&bytes, len1);
ASSERT_EQ(0, memcmp(bytes.c_str(), kStunMessageWithIPv4MappedAddress, len1));
}
@ -933,12 +937,13 @@ TEST_F(StunTest, WriteMessageWithIPv6XorAddressAttribute) {
CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
rtc::ByteBuffer out;
rtc::ByteBufferWriter out;
EXPECT_TRUE(msg.Write(&out));
ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv6XorMappedAddress));
int len1 = static_cast<int>(out.Length());
rtc::ByteBufferReader read_buf(out);
std::string bytes;
out.ReadString(&bytes, len1);
read_buf.ReadString(&bytes, len1);
ASSERT_EQ(0,
memcmp(bytes.c_str(), kStunMessageWithIPv6XorMappedAddress, len1));
}
@ -963,12 +968,13 @@ TEST_F(StunTest, WriteMessageWithIPv4XoreAddressAttribute) {
CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
rtc::ByteBuffer out;
rtc::ByteBufferWriter out;
EXPECT_TRUE(msg.Write(&out));
ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv4XorMappedAddress));
int len1 = static_cast<int>(out.Length());
rtc::ByteBufferReader read_buf(out);
std::string bytes;
out.ReadString(&bytes, len1);
read_buf.ReadString(&bytes, len1);
ASSERT_EQ(0,
memcmp(bytes.c_str(), kStunMessageWithIPv4XorMappedAddress, len1));
}
@ -1061,7 +1067,7 @@ TEST_F(StunTest, WriteMessageWithAnErrorCodeAttribute) {
EXPECT_TRUE(msg.AddAttribute(errorcode));
CheckStunHeader(msg, STUN_BINDING_ERROR_RESPONSE, (size - 20));
rtc::ByteBuffer out;
rtc::ByteBufferWriter out;
EXPECT_TRUE(msg.Write(&out));
ASSERT_EQ(size, out.Length());
// No padding.
@ -1084,7 +1090,7 @@ TEST_F(StunTest, WriteMessageWithAUInt16ListAttribute) {
EXPECT_TRUE(msg.AddAttribute(list));
CheckStunHeader(msg, STUN_BINDING_REQUEST, (size - 20));
rtc::ByteBuffer out;
rtc::ByteBufferWriter out;
EXPECT_TRUE(msg.Write(&out));
ASSERT_EQ(size, out.Length());
// Check everything up to the padding.
@ -1104,7 +1110,7 @@ TEST_F(StunTest, WriteMessageWithOriginAttribute) {
new StunByteStringAttribute(STUN_ATTR_ORIGIN, kTestOrigin);
EXPECT_TRUE(msg.AddAttribute(origin));
rtc::ByteBuffer out;
rtc::ByteBufferWriter out;
EXPECT_TRUE(msg.Write(&out));
ASSERT_EQ(size, out.Length());
// Check everything up to the padding
@ -1115,7 +1121,7 @@ TEST_F(StunTest, WriteMessageWithOriginAttribute) {
void CheckFailureToRead(const unsigned char* testcase, size_t length) {
StunMessage msg;
const char* input = reinterpret_cast<const char*>(testcase);
rtc::ByteBuffer buf(input, length);
rtc::ByteBufferReader buf(input, length);
ASSERT_FALSE(msg.Read(&buf));
}
@ -1207,7 +1213,7 @@ TEST_F(StunTest, ValidateMessageIntegrity) {
// the RFC5769 test messages used include attributes not found in basic STUN.
TEST_F(StunTest, AddMessageIntegrity) {
IceMessage msg;
rtc::ByteBuffer buf(
rtc::ByteBufferReader buf(
reinterpret_cast<const char*>(kRfc5769SampleRequestWithoutMI),
sizeof(kRfc5769SampleRequestWithoutMI));
EXPECT_TRUE(msg.Read(&buf));
@ -1218,14 +1224,14 @@ TEST_F(StunTest, AddMessageIntegrity) {
EXPECT_EQ(0, memcmp(
mi_attr->bytes(), kCalculatedHmac1, sizeof(kCalculatedHmac1)));
rtc::ByteBuffer buf1;
rtc::ByteBufferWriter buf1;
EXPECT_TRUE(msg.Write(&buf1));
EXPECT_TRUE(StunMessage::ValidateMessageIntegrity(
reinterpret_cast<const char*>(buf1.Data()), buf1.Length(),
kRfc5769SampleMsgPassword));
IceMessage msg2;
rtc::ByteBuffer buf2(
rtc::ByteBufferReader buf2(
reinterpret_cast<const char*>(kRfc5769SampleResponseWithoutMI),
sizeof(kRfc5769SampleResponseWithoutMI));
EXPECT_TRUE(msg2.Read(&buf2));
@ -1236,7 +1242,7 @@ TEST_F(StunTest, AddMessageIntegrity) {
EXPECT_EQ(
0, memcmp(mi_attr2->bytes(), kCalculatedHmac2, sizeof(kCalculatedHmac2)));
rtc::ByteBuffer buf3;
rtc::ByteBufferWriter buf3;
EXPECT_TRUE(msg2.Write(&buf3));
EXPECT_TRUE(StunMessage::ValidateMessageIntegrity(
reinterpret_cast<const char*>(buf3.Data()), buf3.Length(),
@ -1282,13 +1288,13 @@ TEST_F(StunTest, ValidateFingerprint) {
TEST_F(StunTest, AddFingerprint) {
IceMessage msg;
rtc::ByteBuffer buf(
rtc::ByteBufferReader buf(
reinterpret_cast<const char*>(kRfc5769SampleRequestWithoutMI),
sizeof(kRfc5769SampleRequestWithoutMI));
EXPECT_TRUE(msg.Read(&buf));
EXPECT_TRUE(msg.AddFingerprint());
rtc::ByteBuffer buf1;
rtc::ByteBufferWriter buf1;
EXPECT_TRUE(msg.Write(&buf1));
EXPECT_TRUE(StunMessage::ValidateFingerprint(
reinterpret_cast<const char*>(buf1.Data()), buf1.Length()));
@ -1331,7 +1337,7 @@ TEST_F(StunTest, ReadRelayMessage) {
const char* input = reinterpret_cast<const char*>(kRelayMessage);
size_t size = sizeof(kRelayMessage);
rtc::ByteBuffer buf(input, size);
rtc::ByteBufferReader buf(input, size);
EXPECT_TRUE(msg.Read(&buf));
EXPECT_EQ(STUN_BINDING_REQUEST, msg.type());
@ -1427,20 +1433,22 @@ TEST_F(StunTest, ReadRelayMessage) {
bytes2->CopyBytes("abcdefg");
EXPECT_TRUE(msg2.AddAttribute(bytes2));
rtc::ByteBuffer out;
rtc::ByteBufferWriter out;
EXPECT_TRUE(msg.Write(&out));
EXPECT_EQ(size, out.Length());
size_t len1 = out.Length();
rtc::ByteBufferReader read_buf(out);
std::string outstring;
out.ReadString(&outstring, len1);
read_buf.ReadString(&outstring, len1);
EXPECT_EQ(0, memcmp(outstring.c_str(), input, len1));
rtc::ByteBuffer out2;
rtc::ByteBufferWriter out2;
EXPECT_TRUE(msg2.Write(&out2));
EXPECT_EQ(size, out2.Length());
size_t len2 = out2.Length();
rtc::ByteBufferReader read_buf2(out2);
std::string outstring2;
out2.ReadString(&outstring2, len2);
read_buf2.ReadString(&outstring2, len2);
EXPECT_EQ(0, memcmp(outstring2.c_str(), input, len2));
}

4
webrtc/p2p/base/stunrequest.cc
View File

@ -138,7 +138,7 @@ bool StunRequestManager::CheckResponse(const char* data, size_t size) {
// Parse the STUN message and continue processing as usual.
rtc::ByteBuffer buf(data, size);
rtc::ByteBufferReader buf(data, size);
rtc::scoped_ptr<StunMessage> response(iter->second->msg_->CreateNew());
if (!response->Read(&buf)) {
LOG(LS_WARNING) << "Failed to read STUN response " << rtc::hex_encode(id);
@ -213,7 +213,7 @@ void StunRequest::OnMessage(rtc::Message* pmsg) {
tstamp_ = rtc::Time64();
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
msg_->Write(&buf);
manager_->SignalSendPacket(buf.Data(), buf.Length(), this);

4
webrtc/p2p/base/stunserver.cc
View File

@ -28,7 +28,7 @@ void StunServer::OnPacket(
const rtc::SocketAddress& remote_addr,
const rtc::PacketTime& packet_time) {
// Parse the STUN message; eat any messages that fail to parse.
rtc::ByteBuffer bbuf(buf, size);
rtc::ByteBufferReader bbuf(buf, size);
StunMessage msg;
if (!msg.Read(&bbuf)) {
return;
@ -72,7 +72,7 @@ void StunServer::SendErrorResponse(
void StunServer::SendResponse(
const StunMessage& msg, const rtc::SocketAddress& addr) {
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
msg.Write(&buf);
rtc::PacketOptions options;
if (socket_->SendTo(buf.Data(), buf.Length(), addr, options) < 0)

4
webrtc/p2p/base/stunserver_unittest.cc
View File

@ -39,7 +39,7 @@ class StunServerTest : public testing::Test {
worker_.Start();
}
void Send(const StunMessage& msg) {
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
msg.Write(&buf);
Send(buf.Data(), static_cast<int>(buf.Length()));
}
@ -54,7 +54,7 @@ class StunServerTest : public testing::Test {
rtc::TestClient::Packet* packet =
client_->NextPacket(rtc::TestClient::kTimeoutMs);
if (packet) {
rtc::ByteBuffer buf(packet->buf, packet->size);
rtc::ByteBufferReader buf(packet->buf, packet->size);
msg = new StunMessage();
msg->Read(&buf);
delete packet;

4
webrtc/p2p/base/turnport.cc
View File

@ -786,7 +786,7 @@ void TurnPort::OnAllocateRequestTimeout() {
void TurnPort::HandleDataIndication(const char* data, size_t size,
const rtc::PacketTime& packet_time) {
// Read in the message, and process according to RFC5766, Section 10.4.
rtc::ByteBuffer buf(data, size);
rtc::ByteBufferReader buf(data, size);
TurnMessage msg;
if (!msg.Read(&buf)) {
LOG_J(LS_WARNING, this) << "Received invalid TURN data indication";
@ -1425,7 +1425,7 @@ void TurnEntry::SendChannelBindRequest(int delay) {
int TurnEntry::Send(const void* data, size_t size, bool payload,
const rtc::PacketOptions& options) {
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
if (state_ != STATE_BOUND) {
// If we haven't bound the channel yet, we have to use a Send Indication.
TurnMessage msg;

8
webrtc/p2p/base/turnserver.cc
View File

@ -216,7 +216,7 @@ void TurnServer::OnInternalPacket(rtc::AsyncPacketSocket* socket,
void TurnServer::HandleStunMessage(TurnServerConnection* conn, const char* data,
size_t size) {
TurnMessage msg;
rtc::ByteBuffer buf(data, size);
rtc::ByteBufferReader buf(data, size);
if (!msg.Read(&buf) || (buf.Length() > 0)) {
LOG(LS_WARNING) << "Received invalid STUN message";
return;
@ -489,7 +489,7 @@ void TurnServer::SendErrorResponseWithAlternateServer(
}
void TurnServer::SendStun(TurnServerConnection* conn, StunMessage* msg) {
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
// Add a SOFTWARE attribute if one is set.
if (!software_.empty()) {
VERIFY(msg->AddAttribute(
@ -500,7 +500,7 @@ void TurnServer::SendStun(TurnServerConnection* conn, StunMessage* msg) {
}
void TurnServer::Send(TurnServerConnection* conn,
const rtc::ByteBuffer& buf) {
const rtc::ByteBufferWriter& buf) {
rtc::PacketOptions options;
conn->socket()->SendTo(buf.Data(), buf.Length(), conn->src(), options);
}
@ -794,7 +794,7 @@ void TurnServerAllocation::OnExternalPacket(
Channel* channel = FindChannel(addr);
if (channel) {
// There is a channel bound to this address. Send as a channel message.
rtc::ByteBuffer buf;
rtc::ByteBufferWriter buf;
buf.WriteUInt16(channel->id());
buf.WriteUInt16(static_cast<uint16_t>(size));
buf.WriteBytes(data, size);

4
webrtc/p2p/base/turnserver.h
View File

@ -23,7 +23,7 @@
#include "webrtc/base/socketaddress.h"
namespace rtc {
class ByteBuffer;
class ByteBufferWriter;
class PacketSocketFactory;
class Thread;
}
@ -246,7 +246,7 @@ class TurnServer : public sigslot::has_slots<> {
const rtc::SocketAddress& addr);
void SendStun(TurnServerConnection* conn, StunMessage* msg);
void Send(TurnServerConnection* conn, const rtc::ByteBuffer& buf);
void Send(TurnServerConnection* conn, const rtc::ByteBufferWriter& buf);
void OnAllocationDestroyed(TurnServerAllocation* allocation);
void DestroyInternalSocket(rtc::AsyncPacketSocket* socket);

10
webrtc/p2p/stunprober/stunprober.cc
View File

@ -93,7 +93,7 @@ class StunProber::Requester : public sigslot::has_slots<> {
// Temporary SocketAddress and buffer for RecvFrom.
rtc::SocketAddress addr_;
rtc::scoped_ptr<rtc::ByteBuffer> response_packet_;
rtc::scoped_ptr<rtc::ByteBufferWriter> response_packet_;
std::vector<Request*> requests_;
std::vector<rtc::SocketAddress> server_ips_;
@ -111,7 +111,7 @@ StunProber::Requester::Requester(
const std::vector<rtc::SocketAddress>& server_ips)
: prober_(prober),
socket_(socket),
response_packet_(new rtc::ByteBuffer(nullptr, kMaxUdpBufferSize)),
response_packet_(new rtc::ByteBufferWriter(nullptr, kMaxUdpBufferSize)),
server_ips_(server_ips),
thread_checker_(prober->thread_checker_) {
socket_->SignalReadPacket.connect(
@ -140,8 +140,8 @@ void StunProber::Requester::SendStunRequest() {
rtc::CreateRandomString(cricket::kStunTransactionIdLength));
message.SetType(cricket::STUN_BINDING_REQUEST);
rtc::scoped_ptr<rtc::ByteBuffer> request_packet(
new rtc::ByteBuffer(nullptr, kMaxUdpBufferSize));
rtc::scoped_ptr<rtc::ByteBufferWriter> request_packet(
new rtc::ByteBufferWriter(nullptr, kMaxUdpBufferSize));
if (!message.Write(request_packet.get())) {
prober_->ReportOnFinished(WRITE_FAILED);
return;
@ -170,7 +170,7 @@ void StunProber::Requester::SendStunRequest() {
void StunProber::Requester::Request::ProcessResponse(const char* buf,
size_t buf_len) {
int64_t now = rtc::Time64();
rtc::ByteBuffer message(buf, buf_len);
rtc::ByteBufferReader message(buf, buf_len);
cricket::StunMessage stun_response;
if (!stun_response.Read(&message)) {
// Invalid or incomplete STUN packet.