Lazily allocate output buffer for AsyncTCPSocket.

webrtc/base/asynctcpsocket.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 37 matching lines @@
   }
   return owned_socket.release();
 }
 
 AsyncTCPSocketBase::AsyncTCPSocketBase(AsyncSocket* socket, bool listen,
                                        size_t max_packet_size)
     : socket_(socket),
       listen_(listen),
       insize_(max_packet_size),
       inpos_(0),
-      outsize_(max_packet_size),
-      outpos_(0) {
+      max_outsize_(max_packet_size) {
   if (!listen_) {
     // Listening sockets don't send/receive data, so they don't need buffers.
     inbuf_.reset(new char[insize_]);
-    outbuf_.reset(new char[outsize_]);
   }
 
   RTC_DCHECK(socket_.get() != NULL);
   socket_->SignalConnectEvent.connect(
       this, &AsyncTCPSocketBase::OnConnectEvent);
   socket_->SignalReadEvent.connect(this, &AsyncTCPSocketBase::OnReadEvent);
   socket_->SignalWriteEvent.connect(this, &AsyncTCPSocketBase::OnWriteEvent);
   socket_->SignalCloseEvent.connect(this, &AsyncTCPSocketBase::OnCloseEvent);
 
   if (listen_) {
@@ skipping 57 matching lines @@
   const SocketAddress& remote_address = GetRemoteAddress();
   if (addr == remote_address)
     return Send(pv, cb, options);
   // Remote address may be empty if there is a sudden network change.
   RTC_DCHECK(remote_address.IsNil());
   socket_->SetError(ENOTCONN);
   return -1;
 }
 
 int AsyncTCPSocketBase::SendRaw(const void * pv, size_t cb) {
-  if (outpos_ + cb > outsize_) {
+  if (outbuf_.size() + cb > max_outsize_) {
     socket_->SetError(EMSGSIZE);
     return -1;
   }
 
-  RTC_DCHECK(outbuf_.get());
-  memcpy(outbuf_.get() + outpos_, pv, cb);
-  outpos_ += cb;
+  RTC_DCHECK(!listen_);
+  outbuf_.AppendData(static_cast<const uint8_t*>(pv), cb);
 
   return FlushOutBuffer();
 }
 
 int AsyncTCPSocketBase::FlushOutBuffer() {
-  RTC_DCHECK(outbuf_.get());
-  int res = socket_->Send(outbuf_.get(), outpos_);
+  RTC_DCHECK(!listen_);
+  int res = socket_->Send(outbuf_.data(), outbuf_.size());
   if (res <= 0) {
     return res;
   }
-  if (static_cast<size_t>(res) <= outpos_) {
-    outpos_ -= res;
-  } else {
+  if (static_cast<size_t>(res) > outbuf_.size()) {
     RTC_NOTREACHED();
     return -1;
   }
-  if (outpos_ > 0) {
-    memmove(outbuf_.get(), outbuf_.get() + res, outpos_);
+  size_t new_size = outbuf_.size() - res;
+  if (new_size > 0) {
+    memmove(outbuf_.data(), outbuf_.data() + res, new_size);
   }
+  outbuf_.SetSize(new_size);
   return res;
 }
 
 void AsyncTCPSocketBase::AppendToOutBuffer(const void* pv, size_t cb) {
-  RTC_DCHECK(outpos_ + cb < outsize_);
-  RTC_DCHECK(outbuf_.get());
-  memcpy(outbuf_.get() + outpos_, pv, cb);
-  outpos_ += cb;
+  RTC_DCHECK(outbuf_.size() + cb <= max_outsize_);
+  RTC_DCHECK(!listen_);
+  outbuf_.AppendData(static_cast<const uint8_t*>(pv), cb);
 }
 
 void AsyncTCPSocketBase::OnConnectEvent(AsyncSocket* socket) {
   SignalConnect(this);
 }
 
 void AsyncTCPSocketBase::OnReadEvent(AsyncSocket* socket) {
   RTC_DCHECK(socket_.get() == socket);
 
   if (listen_) {
@@ skipping 29 matching lines @@
       LOG(LS_ERROR) << "input buffer overflow";
       RTC_NOTREACHED();
       inpos_ = 0;
     }
   }
 }
 
 void AsyncTCPSocketBase::OnWriteEvent(AsyncSocket* socket) {
   RTC_DCHECK(socket_.get() == socket);
 
-  if (outpos_ > 0) {
+  if (outbuf_.size() > 0) {
     FlushOutBuffer();
   }
 
-  if (outpos_ == 0) {
+  if (outbuf_.size() == 0) {
     SignalReadyToSend(this);
   }
 }
 
 void AsyncTCPSocketBase::OnCloseEvent(AsyncSocket* socket, int error) {
   SignalClose(this, error);
 }
 
 // AsyncTCPSocket
 // Binds and connects |socket| and creates AsyncTCPSocket for
@@ skipping 59 matching lines @@
       memmove(data, data + kPacketLenSize + pkt_len, *len);
     }
   }
 }
 
 void AsyncTCPSocket::HandleIncomingConnection(AsyncSocket* socket) {
   SignalNewConnection(this, new AsyncTCPSocket(socket, false));
 }
 
 }  // namespace rtc