Lazily allocate input buffer for AsyncTCPSocket.

webrtc/base/asynctcpsocket.cc

Index: webrtc/base/asynctcpsocket.cc
diff --git a/webrtc/base/asynctcpsocket.cc b/webrtc/base/asynctcpsocket.cc
index 31dec92367fc1c876e1b1c4fba1c92eb49b8c91f..f8b6a0a02b55c7ca5608c578a244fd97825150e7 100644
--- a/webrtc/base/asynctcpsocket.cc
+++ b/webrtc/base/asynctcpsocket.cc
@@ -12,6 +12,8 @@
 
 #include <string.h>
 
+#include <algorithm>
+
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
@@ -30,6 +32,10 @@ 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|
@@ -53,12 +59,11 @@ 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);
@@ -193,24 +198,43 @@ void AsyncTCPSocketBase::OnReadEvent(AsyncSocket* 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;
       }
-      return;
     }
 
-    inpos_ += len;
+    if (!total_recv) {
+      return;
+    }
 
-    ProcessInput(inbuf_.get(), &inpos_);
+    size_t size = inbuf_.size();
+    ProcessInput(inbuf_.data<char>(), &size);
 
-    if (inpos_ >= insize_) {
+    if (size > inbuf_.size()) {
       LOG(LS_ERROR) << "input buffer overflow";
       RTC_NOTREACHED();
-      inpos_ = 0;
+      inbuf_.Clear();
+    } else {
+      inbuf_.SetSize(size);
     }
   }
 }