Split ByteBuffer into writer/reader objects.

webrtc/p2p/base/relayserver_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 58 matching lines @@
   }
   void Bind() {
     rtc::scoped_ptr<StunMessage> req(
         CreateStunMessage(STUN_BINDING_REQUEST));
     AddUsernameAttr(req.get(), username_);
     Send2(req.get());
     delete Receive1();
   }
 
   void Send1(const StunMessage* msg) {
-    rtc::ByteBuffer buf;
+    rtc::ByteBufferWriter buf;
     msg->Write(&buf);
     SendRaw1(buf.Data(), static_cast<int>(buf.Length()));
   }
   void Send2(const StunMessage* msg) {
-    rtc::ByteBuffer buf;
+    rtc::ByteBufferWriter buf;
     msg->Write(&buf);
     SendRaw2(buf.Data(), static_cast<int>(buf.Length()));
   }
   void SendRaw1(const char* data, int len) {
     return Send(client1_.get(), data, len, server_int_addr);
   }
   void SendRaw2(const char* data, int len) {
     return Send(client2_.get(), data, len, server_ext_addr);
   }
   void Send(rtc::TestClient* client, const char* data,
@@ skipping 18 matching lines @@
     return ReceiveRaw(client1_.get());
   }
   std::string ReceiveRaw2() {
     return ReceiveRaw(client2_.get());
   }
   StunMessage* Receive(rtc::TestClient* client) {
     StunMessage* msg = NULL;
     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;
   }
   std::string ReceiveRaw(rtc::TestClient* client) {
     std::string raw;
     rtc::TestClient::Packet* packet =
         client->NextPacket(rtc::TestClient::kTimeoutMs);
     if (packet) {
       raw = std::string(packet->buf, packet->size);
@@ skipping 159 matching lines @@
   Send2(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res);
   EXPECT_EQ(STUN_DATA_INDICATION, res->type());
 
   const StunByteStringAttribute* recv_data =
       res->GetByteString(STUN_ATTR_DATA);
   ASSERT_TRUE(recv_data != NULL);
 
-  rtc::ByteBuffer buf(recv_data->bytes(), recv_data->length());
+  rtc::ByteBufferReader buf(recv_data->bytes(), recv_data->length());
   rtc::scoped_ptr<StunMessage> res2(new StunMessage());
   EXPECT_TRUE(res2->Read(&buf));
   EXPECT_EQ(STUN_BINDING_REQUEST, res2->type());
   EXPECT_EQ(req->transaction_id(), res2->transaction_id());
 
   const StunAddressAttribute* src_addr =
       res->GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
   ASSERT_TRUE(src_addr != NULL);
   EXPECT_EQ(1, src_addr->family());
   EXPECT_EQ(client2_addr.ipaddr(), src_addr->ipaddr());
@@ skipping 204 matching lines @@
   const StunErrorCodeAttribute* err = res->GetErrorCode();
   ASSERT_TRUE(err != NULL);
   EXPECT_EQ(6, err->eclass());
   EXPECT_EQ(0, err->number());
   EXPECT_EQ("Operation Not Supported", err->reason());
 
   // Also verify that traffic from the external client is ignored.
   SendRaw2(msg2, static_cast<int>(strlen(msg2)));
   EXPECT_TRUE(ReceiveRaw1().empty());
 }