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 up to the maximum size so that at least

[tommi, 2016/03/01 09:22:13]

do you mean minimum?

[joachim, 2016/03/01 10:55:23]

No, 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).

Updated comment accordingly, I hope that's a bit clearer.

[tommi, 2016/03/01 17:42:41]

Thanks.

+// 128 bytes can be received.
+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 114 matching lines @@
       // 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: Do something better like forwarding the error to the user.

[tommi, 2016/03/01 09:22:13]

can you assign the TODO to someone?

[joachim, 2016/03/01 10:55:23]

Assigned both TODOs in the file to "henrike" who committed these lines.

[tommi, 2016/03/01 17:42:42]

henrike doesn't work on webrtc anymore actually.  Can you assign to someone that
has been working in this file recently?

[joachim, 2016/03/02 08:32:17]

Last changes to that file were from stefan@ and pbos@, who do you suggest I
should assign the TODOs to?
https://chromium.googlesource.com/external/webrtc/+log/master/webrtc/base/asy...

+        if (!socket_->IsBlocking()) {
+          LOG(LS_ERROR) << "Recv() returned error: " << socket_->GetError();

[tommi, 2016/03/01 09:22:13]

nit: You can use LOG_IF() to combine the LOG and the check for blocking.

[joachim, 2016/03/01 10:55:23]

Where is LOG_IF defined? I think it's only available in Chromium, but not in
WebRTC - otherwise, which header should I include to get it?

[tommi, 2016/03/01 17:42:42]

oh, sorry. fine as is.

+        }
+        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