Split ByteBuffer into writer/reader objects.

webrtc/p2p/base/stun_unittest.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 44 matching lines @@
     } else {
       ASSERT_TRUE(addr->family() == STUN_ADDRESS_IPV6 ||
                   addr->family() == STUN_ADDRESS_IPV4);
     }
   }
 
   size_t ReadStunMessageTestCase(StunMessage* msg,
                                  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);
     } else {
       return 0;
     }
   }
 };
 
 
@@ skipping 656 matching lines @@
 
   // Owner with a different transaction ID.
   msg2.SetTransactionID("ABCDABCDABCD");
   StunXorAddressAttribute addr2(STUN_ATTR_XOR_MAPPED_ADDRESS, 20, NULL);
   addr2.SetIP(addr->ipaddr());
   addr2.SetPort(addr->port());
   addr2.SetOwner(&msg2);
   // 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());
 }
 
 TEST_F(StunTest, SetIPv4XorAddressAttributeOwner) {
   // Unlike the IPv6XorAddressAttributeOwner test, IPv4 XOR address attributes
   // should _not_ be affected by a change in owner. IPv4 XOR address uses the
   // magic cookie value which is fixed.
   StunMessage msg;
   StunMessage msg2;
@@ skipping 11 matching lines @@
 
   // Owner with a different transaction ID.
   msg2.SetTransactionID("ABCDABCDABCD");
   StunXorAddressAttribute addr2(STUN_ATTR_XOR_MAPPED_ADDRESS, 20, NULL);
   addr2.SetIP(addr->ipaddr());
   addr2.SetPort(addr->port());
   addr2.SetOwner(&msg2);
   // 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.
   ASSERT_EQ(0,
             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));
 }
 
 TEST_F(StunTest, CreateIPv6AddressAttribute) {
   rtc::IPAddress test_ip(kIPv6TestAddress2);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
   addr->SetAddress(test_addr);
@@ skipping 53 matching lines @@
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
   addr->SetAddress(test_addr);
   EXPECT_TRUE(msg.AddAttribute(addr));
 
   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));
 }
 
 TEST_F(StunTest, WriteMessageWithIPv4AddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv4MappedAddress);
 
   rtc::IPAddress test_ip(kIPv4TestAddress1);
 
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort4);
   addr->SetAddress(test_addr);
   EXPECT_TRUE(msg.AddAttribute(addr));
 
   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));
 }
 
 TEST_F(StunTest, WriteMessageWithIPv6XorAddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv6XorMappedAddress);
 
   rtc::IPAddress test_ip(kIPv6TestAddress1);
 
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId2),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort1);
   addr->SetAddress(test_addr);
   EXPECT_TRUE(msg.AddAttribute(addr));
 
   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));
 }
 
 TEST_F(StunTest, WriteMessageWithIPv4XoreAddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv4XorMappedAddress);
 
   rtc::IPAddress test_ip(kIPv4TestAddress1);
 
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort3);
   addr->SetAddress(test_addr);
   EXPECT_TRUE(msg.AddAttribute(addr));
 
   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));
 }
 
 TEST_F(StunTest, ReadByteStringAttribute) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg, kStunMessageWithByteStringAttribute);
 
   CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
@@ skipping 72 matching lines @@
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
   StunErrorCodeAttribute* errorcode = StunAttribute::CreateErrorCode();
   errorcode->SetCode(kTestErrorCode);
   errorcode->SetReason(kTestErrorReason);
   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.
   ASSERT_EQ(0, memcmp(out.Data(), kStunMessageWithErrorAttribute, size));
 }
 
 TEST_F(StunTest, WriteMessageWithAUInt16ListAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithUInt16ListAttribute);
 
   msg.SetType(STUN_BINDING_REQUEST);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId2),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
   StunUInt16ListAttribute* list = StunAttribute::CreateUnknownAttributes();
   list->AddType(0x1U);
   list->AddType(0x1000U);
   list->AddType(0xAB0CU);
   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.
   ASSERT_EQ(0,
             memcmp(out.Data(), kStunMessageWithUInt16ListAttribute, size - 2));
 }
 
 TEST_F(StunTest, WriteMessageWithOriginAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithOriginAttribute);
 
   msg.SetType(STUN_BINDING_REQUEST);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   StunByteStringAttribute* origin =
       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
   ASSERT_EQ(0, memcmp(out.Data(), kStunMessageWithOriginAttribute, size - 2));
 }
 
 // Test that we fail to read messages with invalid lengths.
 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));
 }
 
 TEST_F(StunTest, FailToReadInvalidMessages) {
   CheckFailureToRead(kStunMessageWithZeroLength,
                      kRealLengthOfInvalidLengthTestCases);
   CheckFailureToRead(kStunMessageWithSmallLength,
                      kRealLengthOfInvalidLengthTestCases);
   CheckFailureToRead(kStunMessageWithExcessLength,
                      kRealLengthOfInvalidLengthTestCases);
@@ skipping 71 matching lines @@
     EXPECT_EQ(i >= sizeof(buf) - 8, StunMessage::ValidateMessageIntegrity(
         buf, sizeof(buf), kRfc5769SampleMsgPassword));
   }
 }
 
 // Validate that we generate correct MESSAGE-INTEGRITY attributes.
 // Note the use of IceMessage instead of StunMessage; this is necessary because
 // 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));
   EXPECT_TRUE(msg.AddMessageIntegrity(kRfc5769SampleMsgPassword));
   const StunByteStringAttribute* mi_attr =
       msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY);
   EXPECT_EQ(20U, mi_attr->length());
   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));
   EXPECT_TRUE(msg2.AddMessageIntegrity(kRfc5769SampleMsgPassword));
   const StunByteStringAttribute* mi_attr2 =
       msg2.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY);
   EXPECT_EQ(20U, mi_attr2->length());
   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(),
         kRfc5769SampleMsgPassword));
 }
 
 // Check our STUN message validation code against the RFC5769 test messages.
 TEST_F(StunTest, ValidateFingerprint) {
   EXPECT_TRUE(StunMessage::ValidateFingerprint(
       reinterpret_cast<const char*>(kRfc5769SampleRequest),
@@ skipping 25 matching lines @@
       buf[i - 1] ^= 0x01;
     EXPECT_FALSE(StunMessage::ValidateFingerprint(buf, sizeof(buf)));
   }
   // Put them all back to normal and the check should pass again.
   buf[sizeof(buf) - 1] ^= 0x01;
   EXPECT_TRUE(StunMessage::ValidateFingerprint(buf, sizeof(buf)));
 }
 
 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()));
 }
 
 // Sample "GTURN" relay message.
 static const unsigned char kRelayMessage[] = {
   0x00, 0x01, 0x00, 88,    // message header
   0x21, 0x12, 0xA4, 0x42,  // magic cookie
   '0', '1', '2', '3',      // transaction id
@@ skipping 22 matching lines @@
   'a', 'b', 'c', 'd',
   'e', 'f', 'g', 0         // DATA must be padded per rfc5766.
 };
 
 // Test that we can read the GTURN-specific fields.
 TEST_F(StunTest, ReadRelayMessage) {
   RelayMessage msg, msg2;
 
   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());
   EXPECT_EQ(size - 20, msg.length());
   EXPECT_EQ("0123456789ab", msg.transaction_id());
 
   msg2.SetType(STUN_BINDING_REQUEST);
   msg2.SetTransactionID("0123456789ab");
 
   in_addr legacy_in_addr;
@@ skipping 75 matching lines @@
 
   bytes = msg.GetByteString(STUN_ATTR_DATA);
   ASSERT_TRUE(bytes != NULL);
   EXPECT_EQ(7U, bytes->length());
   EXPECT_EQ("abcdefg", bytes->GetString());
 
   bytes2 = StunAttribute::CreateByteString(STUN_ATTR_DATA);
   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));
 }
 
 }  // namespace cricket