Lazily allocate input 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.
  */
 
 #include "webrtc/base/asynctcpsocket.h"
 
 #include <string.h>
 
+#include <algorithm>
+
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 
 #if defined(WEBRTC_POSIX)
 #include <errno.h>
 #endif  // WEBRTC_POSIX
 
 namespace rtc {
 
 static const size_t kMaxPacketSize = 64 * 1024;
 
 typedef uint16_t PacketLength;
 static const size_t kPacketLenSize = sizeof(PacketLength);
 
 static const size_t kBufSize = kMaxPacketSize + kPacketLenSize;
 
+// The input buffer will be resized so that at least kMinimumRecvSize bytes can
+// be received (but it will not grow above the maximum size passed to the
+// constructor).
+static const size_t kMinimumRecvSize = 128;
+
 static const int kListenBacklog = 5;
 
 // Binds and connects |socket|
 AsyncSocket* AsyncTCPSocketBase::ConnectSocket(
     rtc::AsyncSocket* socket,
     const rtc::SocketAddress& bind_address,
     const rtc::SocketAddress& remote_address) {
   rtc::scoped_ptr<rtc::AsyncSocket> owned_socket(socket);
   if (socket->Bind(bind_address) < 0) {
     LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
     return NULL;
   }
   if (socket->Connect(remote_address) < 0) {
     LOG(LS_ERROR) << "Connect() failed with error " << socket->GetError();
     return NULL;
   }
   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),
+      max_insize_(max_packet_size),
       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_]);
+    inbuf_.EnsureCapacity(kMinimumRecvSize);
   }
 
   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 103 matching lines @@
   SignalConnect(this);
 }
 
 void AsyncTCPSocketBase::OnReadEvent(AsyncSocket* socket) {
   RTC_DCHECK(socket_.get() == socket);
 
   if (listen_) {
     rtc::SocketAddress address;
     rtc::AsyncSocket* new_socket = socket->Accept(&address);
     if (!new_socket) {
-      // TODO: Do something better like forwarding the error
+      // TODO(stefan): Do something better like forwarding the error
       // to the user.
       LOG(LS_ERROR) << "TCP accept failed with error " << socket_->GetError();
       return;
     }
 
     HandleIncomingConnection(new_socket);
 
     // Prime a read event in case data is waiting.
     new_socket->SignalReadEvent(new_socket);
   } else {
-    RTC_DCHECK(inbuf_.get());
-    int len = socket_->Recv(inbuf_.get() + inpos_, insize_ - inpos_);
-    if (len < 0) {
-      // TODO: Do something better like forwarding the error to the user.
-      if (!socket_->IsBlocking()) {
-        LOG(LS_ERROR) << "Recv() returned error: " << socket_->GetError();
+    size_t total_recv = 0;
+    while (true) {
+      size_t free_size = inbuf_.capacity() - inbuf_.size();
+      if (free_size < kMinimumRecvSize && inbuf_.capacity() < max_insize_) {
+        inbuf_.EnsureCapacity(std::min(max_insize_, inbuf_.capacity() * 2));
+        free_size = inbuf_.capacity() - inbuf_.size();
       }
+
+      int len = socket_->Recv(inbuf_.data() + inbuf_.size(), free_size);
+      if (len < 0) {
+        // TODO(stefan): Do something better like forwarding the error to the
+        // user.
+        if (!socket_->IsBlocking()) {
+          LOG(LS_ERROR) << "Recv() returned error: " << socket_->GetError();
+        }
+        break;
+      }
+
+      total_recv += len;
+      inbuf_.SetSize(inbuf_.size() + len);
+      if (!len || static_cast<size_t>(len) < free_size) {
+        break;
+      }
+    }
+
+    if (!total_recv) {
       return;
     }
 
-    inpos_ += len;
+    size_t size = inbuf_.size();
+    ProcessInput(inbuf_.data<char>(), &size);
 
-    ProcessInput(inbuf_.get(), &inpos_);
-
-    if (inpos_ >= insize_) {
+    if (size > inbuf_.size()) {
       LOG(LS_ERROR) << "input buffer overflow";
       RTC_NOTREACHED();
-      inpos_ = 0;
+      inbuf_.Clear();
+    } else {
+      inbuf_.SetSize(size);
     }
   }
 }
 
 void AsyncTCPSocketBase::OnWriteEvent(AsyncSocket* socket) {
   RTC_DCHECK(socket_.get() == socket);
 
   if (outbuf_.size() > 0) {
     FlushOutBuffer();
   }
@@ skipping 71 matching lines @@
       memmove(data, data + kPacketLenSize + pkt_len, *len);
     }
   }
 }
 
 void AsyncTCPSocket::HandleIncomingConnection(AsyncSocket* socket) {
   SignalNewConnection(this, new AsyncTCPSocket(socket, false));
 }
 
 }  // namespace rtc