From f1f87203d703445ca52ef77d28b7ef0591f79cab Mon Sep 17 00:00:00 2001 From: jbauch Date: Wed, 30 Mar 2016 06:43:37 -0700 Subject: [PATCH] Split ByteBuffer into writer/reader objects. 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} --- webrtc/api/sctputils.cc | 6 +- webrtc/base/bitbuffer_unittest.cc | 2 +- webrtc/base/bytebuffer.cc | 286 +++++++++--------- webrtc/base/bytebuffer.h | 130 ++++---- webrtc/base/bytebuffer_unittest.cc | 107 +++---- webrtc/base/socketadapters.cc | 28 +- webrtc/base/socketadapters.h | 11 +- webrtc/libjingle/xmpp/xmppsocket.cc | 20 +- webrtc/libjingle/xmpp/xmppsocket.h | 4 +- webrtc/media/base/rtpdump.cc | 12 +- webrtc/media/base/rtpdump.h | 2 +- webrtc/media/base/rtpdump_unittest.cc | 4 +- webrtc/media/base/testutils.cc | 14 +- webrtc/media/base/testutils.h | 11 +- webrtc/media/base/videoengine_unittest.h | 6 +- .../rtp_rtcp/source/h264_bitstream_parser.cc | 10 +- .../rtp_rtcp/source/h264_sps_parser.cc | 2 +- webrtc/p2p/base/port.cc | 6 +- webrtc/p2p/base/port_unittest.cc | 63 ++-- webrtc/p2p/base/pseudotcp.cc | 4 +- webrtc/p2p/base/relayport.cc | 4 +- webrtc/p2p/base/relayserver.cc | 6 +- webrtc/p2p/base/relayserver_unittest.cc | 11 +- webrtc/p2p/base/stun.cc | 43 +-- webrtc/p2p/base/stun.h | 40 +-- webrtc/p2p/base/stun_unittest.cc | 72 +++-- webrtc/p2p/base/stunrequest.cc | 4 +- webrtc/p2p/base/stunserver.cc | 4 +- webrtc/p2p/base/stunserver_unittest.cc | 4 +- webrtc/p2p/base/turnport.cc | 4 +- webrtc/p2p/base/turnserver.cc | 8 +- webrtc/p2p/base/turnserver.h | 4 +- webrtc/p2p/stunprober/stunprober.cc | 10 +- 33 files changed, 488 insertions(+), 454 deletions(-) diff --git a/webrtc/api/sctputils.cc b/webrtc/api/sctputils.cc index f2d1b0f54a..d6ea601fc3 100644 --- a/webrtc/api/sctputils.cc +++ b/webrtc/api/sctputils.cc @@ -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(), payload.size()); + rtc::ByteBufferReader buffer(payload.data(), 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. diff --git a/webrtc/base/bitbuffer_unittest.cc b/webrtc/base/bitbuffer_unittest.cc index ce42257255..7ba9c738bb 100644 --- a/webrtc/base/bitbuffer_unittest.cc +++ b/webrtc/base/bitbuffer_unittest.cc @@ -188,7 +188,7 @@ uint64_t GolombEncoded(uint32_t val) { } TEST(BitBufferTest, GolombUint32Values) { - ByteBuffer byteBuffer; + ByteBufferWriter byteBuffer; byteBuffer.Resize(16); BitBuffer buffer(reinterpret_cast(byteBuffer.Data()), byteBuffer.Capacity()); diff --git a/webrtc/base/bytebuffer.cc b/webrtc/base/bytebuffer.cc index 8bc1f23670..cf4ce42574 100644 --- a/webrtc/base/bytebuffer.cc +++ b/webrtc/base/bytebuffer.cc @@ -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(), 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(val), 1); -} - -bool ByteBuffer::ReadUInt16(uint16_t* val) { - if (!val) return false; - - uint16_t v; - if (!ReadBytes(reinterpret_cast(&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(&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(&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(&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(&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(&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(&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(&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(&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(), 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(val), 1); +} + +bool ByteBufferReader::ReadUInt16(uint16_t* val) { + if (!val) return false; + + uint16_t v; + if (!ReadBytes(reinterpret_cast(&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(&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(&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(&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 diff --git a/webrtc/base/bytebuffer.h b/webrtc/base/bytebuffer.h index ad2e552ed6..8fd086367d 100644 --- a/webrtc/base/bytebuffer.h +++ b/webrtc/base/bytebuffer.h @@ -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 diff --git a/webrtc/base/bytebuffer_unittest.cc b/webrtc/base/bytebuffer_unittest.cc index 0287d85e6f..723641811f 100644 --- a/webrtc/base/bytebuffer_unittest.cc +++ b/webrtc/base/bytebuffer_unittest.cc @@ -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(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(); } } diff --git a/webrtc/base/socketadapters.cc b/webrtc/base/socketadapters.cc index 2b513dca63..85c126751c 100644 --- a/webrtc/base/socketadapters.cc +++ b/webrtc/base/socketadapters.cc @@ -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(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 diff --git a/webrtc/base/socketadapters.h b/webrtc/base/socketadapters.h index ece591d29f..ae0ed9ac39 100644 --- a/webrtc/base/socketadapters.h +++ b/webrtc/base/socketadapters.h @@ -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); diff --git a/webrtc/libjingle/xmpp/xmppsocket.cc b/webrtc/libjingle/xmpp/xmppsocket.cc index fd07828213..9c1bf8b735 100644 --- a/webrtc/libjingle/xmpp/xmppsocket.cc +++ b/webrtc/libjingle/xmpp/xmppsocket.cc @@ -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(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 diff --git a/webrtc/libjingle/xmpp/xmppsocket.h b/webrtc/libjingle/xmpp/xmppsocket.h index 527b23a5d0..d862afd7de 100644 --- a/webrtc/libjingle/xmpp/xmppsocket.h +++ b/webrtc/libjingle/xmpp/xmppsocket.h @@ -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_; }; diff --git a/webrtc/media/base/rtpdump.cc b/webrtc/media/base/rtpdump.cc index 0cacac705e..a109f2d8e2 100644 --- a/webrtc/media/base/rtpdump.cc +++ b/webrtc/media/base/rtpdump.cc @@ -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(RtpDumpPacket::kHeaderLength + write_len)); buf.WriteUInt16(static_cast(rtcp ? 0 : data_len)); diff --git a/webrtc/media/base/rtpdump.h b/webrtc/media/base/rtpdump.h index 64880c7e28..4ce479277a 100644 --- a/webrtc/media/base/rtpdump.h +++ b/webrtc/media/base/rtpdump.h @@ -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; diff --git a/webrtc/media/base/rtpdump_unittest.cc b/webrtc/media/base/rtpdump_unittest.cc index a5b79c9e94..748ceab120 100644 --- a/webrtc/media/base/rtpdump_unittest.cc +++ b/webrtc/media/base/rtpdump_unittest.cc @@ -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); diff --git a/webrtc/media/base/testutils.cc b/webrtc/media/base/testutils.cc index 33d0a9727d..ec3828c9b8 100644 --- a/webrtc/media/base/testutils.cc +++ b/webrtc/media/base/testutils.cc @@ -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(&packet.data[0]), + rtc::ByteBufferReader buf(reinterpret_cast(&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) { diff --git a/webrtc/media/base/testutils.h b/webrtc/media/base/testutils.h index ba64f82592..6d814efe6d 100644 --- a/webrtc/media/base/testutils.h +++ b/webrtc/media/base/testutils.h @@ -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; diff --git a/webrtc/media/base/videoengine_unittest.h b/webrtc/media/base/videoengine_unittest.h index 929c948d45..01a4f76ca7 100644 --- a/webrtc/media/base/videoengine_unittest.h +++ b/webrtc/media/base/videoengine_unittest.h @@ -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(), p->size()); + rtc::ByteBufferReader buf(p->data(), 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 p(GetRtcpPacket(i)); - // TODO(jbauch): avoid copying the buffer data into the ByteBuffer - rtc::ByteBuffer buf(p->data(), p->size()); + rtc::ByteBufferReader buf(p->data(), p->size()); size_t total_len = 0; // The packet may be a compound RTCP packet. while (total_len < p->size()) { diff --git a/webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.cc b/webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.cc index b78b96dc86..6d8b407459 100644 --- a/webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.cc +++ b/webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.cc @@ -68,9 +68,9 @@ std::vector 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 sps_rbsp( + rtc::scoped_ptr sps_rbsp( ParseRbsp(sps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize)); rtc::BitBuffer sps_parser(reinterpret_cast(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 buffer( + rtc::scoped_ptr buffer( ParseRbsp(pps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize)); rtc::BitBuffer parser(reinterpret_cast(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 slice_rbsp(ParseRbsp( + rtc::scoped_ptr slice_rbsp(ParseRbsp( source + kNaluHeaderAndTypeSize, source_length - kNaluHeaderAndTypeSize)); rtc::BitBuffer slice_reader( reinterpret_cast(slice_rbsp->Data()), diff --git a/webrtc/modules/rtp_rtcp/source/h264_sps_parser.cc b/webrtc/modules/rtp_rtcp/source/h264_sps_parser.cc index 2fb723e3f9..904a9e2562 100644 --- a/webrtc/modules/rtp_rtcp/source/h264_sps_parser.cc +++ b/webrtc/modules/rtp_rtcp/source/h264_sps_parser.cc @@ -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_ diff --git a/webrtc/p2p/base/port.cc b/webrtc/p2p/base/port.cc index 74b9eddf55..d26a9302a8 100644 --- a/webrtc/p2p/base/port.cc +++ b/webrtc/p2p/base/port.cc @@ -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 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); diff --git a/webrtc/p2p/base/port_unittest.cc b/webrtc/p2p/base/port_unittest.cc index d27be29442..fc49f20a5d 100644 --- a/webrtc/p2p/base/port_unittest.cc +++ b/webrtc/p2p/base/port_unittest.cc @@ -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(data), size); - ByteBuffer::ReadPosition pos(buf->GetReadPosition()); - if (!msg->Read(buf)) { + Buffer* buf = new Buffer(static_cast(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 last_stun_buf_; + rtc::scoped_ptr last_stun_buf_; rtc::scoped_ptr 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(), + 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 buf(new ByteBuffer()); + rtc::scoped_ptr 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(), + 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(), 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(), 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(), 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(), 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(), 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(), 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 in_msg, out_msg; - rtc::scoped_ptr buf(new ByteBuffer()); + rtc::scoped_ptr 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 in_msg, out_msg; - rtc::scoped_ptr buf(new ByteBuffer()); + rtc::scoped_ptr 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 in_msg, out_msg; - rtc::scoped_ptr buf(new ByteBuffer()); + rtc::scoped_ptr 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 in_msg, out_msg; - rtc::scoped_ptr buf(new ByteBuffer()); + rtc::scoped_ptr 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 in_msg, out_msg; - rtc::scoped_ptr buf(new ByteBuffer()); + rtc::scoped_ptr 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(), + 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(), + 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(), diff --git a/webrtc/p2p/base/pseudotcp.cc b/webrtc/p2p/base/pseudotcp.cc index 6281315dc1..1dfdcbb894 100644 --- a/webrtc/p2p/base/pseudotcp.cc +++ b/webrtc/p2p/base/pseudotcp.cc @@ -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); diff --git a/webrtc/p2p/base/relayport.cc b/webrtc/p2p/base/relayport.cc index f5ad911796..719604374e 100644 --- a/webrtc/p2p/base/relayport.cc +++ b/webrtc/p2p/base/relayport.cc @@ -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"; diff --git a/webrtc/p2p/base/relayserver.cc b/webrtc/p2p/base/relayserver.cc index aad0070d34..e098cbcd84 100644 --- a/webrtc/p2p/base/relayserver.cc +++ b/webrtc/p2p/base/relayserver.cc @@ -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; } diff --git a/webrtc/p2p/base/relayserver_unittest.cc b/webrtc/p2p/base/relayserver_unittest.cc index 83e5353fc9..3581f7153b 100644 --- a/webrtc/p2p/base/relayserver_unittest.cc +++ b/webrtc/p2p/base/relayserver_unittest.cc @@ -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(buf.Length())); } void Send2(const StunMessage* msg) { - rtc::ByteBuffer buf; + rtc::ByteBufferWriter buf; msg->Write(&buf); SendRaw2(buf.Data(), static_cast(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 res2(new StunMessage()); EXPECT_TRUE(res2->Read(&buf)); EXPECT_EQ(STUN_BINDING_REQUEST, res2->type()); diff --git a/webrtc/p2p/base/stun.cc b/webrtc/p2p/base/stun.cc index 9c22995755..d0f001485d 100644 --- a/webrtc/p2p/base/stun.cc +++ b/webrtc/p2p/base/stun.cc @@ -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(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]); } diff --git a/webrtc/p2p/base/stun.h b/webrtc/p2p/base/stun.h index aada43c322..c0f5cfdfec 100644 --- a/webrtc/p2p/base/stun.h +++ b/webrtc/p2p/base/stun.h @@ -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* attr_types_; diff --git a/webrtc/p2p/base/stun_unittest.cc b/webrtc/p2p/base/stun_unittest.cc index 12492570c4..2213397f2e 100644 --- a/webrtc/p2p/base/stun_unittest.cc +++ b/webrtc/p2p/base/stun_unittest.cc @@ -62,7 +62,7 @@ class StunTest : public ::testing::Test { const unsigned char* testcase, size_t size) { const char* input = reinterpret_cast(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(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(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(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(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(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(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(buf1.Data()), buf1.Length(), kRfc5769SampleMsgPassword)); IceMessage msg2; - rtc::ByteBuffer buf2( + rtc::ByteBufferReader buf2( reinterpret_cast(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(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(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(buf1.Data()), buf1.Length())); @@ -1331,7 +1337,7 @@ TEST_F(StunTest, ReadRelayMessage) { const char* input = reinterpret_cast(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)); } diff --git a/webrtc/p2p/base/stunrequest.cc b/webrtc/p2p/base/stunrequest.cc index 9ceb6dabb7..546dd157d9 100644 --- a/webrtc/p2p/base/stunrequest.cc +++ b/webrtc/p2p/base/stunrequest.cc @@ -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 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); diff --git a/webrtc/p2p/base/stunserver.cc b/webrtc/p2p/base/stunserver.cc index fbc316bd47..bac9fd596b 100644 --- a/webrtc/p2p/base/stunserver.cc +++ b/webrtc/p2p/base/stunserver.cc @@ -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) diff --git a/webrtc/p2p/base/stunserver_unittest.cc b/webrtc/p2p/base/stunserver_unittest.cc index d405979064..973ab2adfc 100644 --- a/webrtc/p2p/base/stunserver_unittest.cc +++ b/webrtc/p2p/base/stunserver_unittest.cc @@ -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(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; diff --git a/webrtc/p2p/base/turnport.cc b/webrtc/p2p/base/turnport.cc index 5f719ce0ff..9ea354c42c 100644 --- a/webrtc/p2p/base/turnport.cc +++ b/webrtc/p2p/base/turnport.cc @@ -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; diff --git a/webrtc/p2p/base/turnserver.cc b/webrtc/p2p/base/turnserver.cc index 14dcf05e89..13974a0bd9 100644 --- a/webrtc/p2p/base/turnserver.cc +++ b/webrtc/p2p/base/turnserver.cc @@ -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(size)); buf.WriteBytes(data, size); diff --git a/webrtc/p2p/base/turnserver.h b/webrtc/p2p/base/turnserver.h index 59751a0759..e520a9ef65 100644 --- a/webrtc/p2p/base/turnserver.h +++ b/webrtc/p2p/base/turnserver.h @@ -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); diff --git a/webrtc/p2p/stunprober/stunprober.cc b/webrtc/p2p/stunprober/stunprober.cc index 18628dafbe..eb9a7a7d3b 100644 --- a/webrtc/p2p/stunprober/stunprober.cc +++ b/webrtc/p2p/stunprober/stunprober.cc @@ -93,7 +93,7 @@ class StunProber::Requester : public sigslot::has_slots<> { // Temporary SocketAddress and buffer for RecvFrom. rtc::SocketAddress addr_; - rtc::scoped_ptr response_packet_; + rtc::scoped_ptr response_packet_; std::vector requests_; std::vector server_ips_; @@ -111,7 +111,7 @@ StunProber::Requester::Requester( const std::vector& 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 request_packet( - new rtc::ByteBuffer(nullptr, kMaxUdpBufferSize)); + rtc::scoped_ptr 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.