Split ByteBuffer into writer/reader objects.

webrtc/p2p/stunprober/stunprober.cc

 /*
  *  Copyright 2015 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 75 matching lines @@
  private:
   Request* GetRequestByAddress(const rtc::IPAddress& ip);
 
   StunProber* prober_;
 
   // The socket for this session.
   rtc::scoped_ptr<rtc::AsyncPacketSocket> socket_;
 
   // Temporary SocketAddress and buffer for RecvFrom.
   rtc::SocketAddress addr_;
-  rtc::scoped_ptr<rtc::ByteBuffer> response_packet_;
+  rtc::scoped_ptr<rtc::ByteBufferWriter> response_packet_;
 
   std::vector<Request*> requests_;
   std::vector<rtc::SocketAddress> server_ips_;
   int16_t num_request_sent_ = 0;
   int16_t num_response_received_ = 0;
 
   rtc::ThreadChecker& thread_checker_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Requester);
 };
 
 StunProber::Requester::Requester(
     StunProber* prober,
     rtc::AsyncPacketSocket* socket,
     const std::vector<rtc::SocketAddress>& server_ips)
     : prober_(prober),
       socket_(socket),
-      response_packet_(new rtc::ByteBuffer(nullptr, kMaxUdpBufferSize)),
+      response_packet_(new rtc::ByteBufferWriter(nullptr, kMaxUdpBufferSize)),
       server_ips_(server_ips),
       thread_checker_(prober->thread_checker_) {
   socket_->SignalReadPacket.connect(
       this, &StunProber::Requester::OnStunResponseReceived);
 }
 
 StunProber::Requester::~Requester() {
   if (socket_) {
     socket_->Close();
   }
   for (auto req : requests_) {
     if (req) {
       delete req;
     }
   }
 }
 
 void StunProber::Requester::SendStunRequest() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   requests_.push_back(new Request());
   Request& request = *(requests_.back());
   cricket::StunMessage message;
 
   // Random transaction ID, STUN_BINDING_REQUEST
   message.SetTransactionID(
       rtc::CreateRandomString(cricket::kStunTransactionIdLength));
   message.SetType(cricket::STUN_BINDING_REQUEST);
 
-  rtc::scoped_ptr<rtc::ByteBuffer> request_packet(
-      new rtc::ByteBuffer(nullptr, kMaxUdpBufferSize));
+  rtc::scoped_ptr<rtc::ByteBufferWriter> request_packet(
+      new rtc::ByteBufferWriter(nullptr, kMaxUdpBufferSize));
   if (!message.Write(request_packet.get())) {
     prober_->ReportOnFinished(WRITE_FAILED);
     return;
   }
 
   auto addr = server_ips_[num_request_sent_];
   request.server_addr = addr.ipaddr();
 
   // The write must succeed immediately. Otherwise, the calculating of the STUN
   // request timing could become too complicated. Callback is ignored by passing
   // empty AsyncCallback.
   rtc::PacketOptions options;
   int rv = socket_->SendTo(const_cast<char*>(request_packet->Data()),
                            request_packet->Length(), addr, options);
   if (rv < 0) {
     prober_->ReportOnFinished(WRITE_FAILED);
     return;
   }
 
   request.sent_time_ms = rtc::Time64();
 
   num_request_sent_++;
   RTC_DCHECK(static_cast<size_t>(num_request_sent_) <= server_ips_.size());
 }
 
 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.
     received_time_ms = 0;
     return;
   }
 
   // Get external address of the socket.
   const cricket::StunAddressAttribute* addr_attr =
       stun_response.GetAddress(cricket::STUN_ATTR_MAPPED_ADDRESS);
@@ skipping 377 matching lines @@
   }
 }
 
 void StunProber::ReportOnFinished(StunProber::Status status) {
   if (observer_) {
     observer_->OnFinished(this, status);
   }
 }
 
 }  // namespace stunprober