commit 3c1657658d017cc0b265d032248502fd46825a8a
author jbauch <jbauch@webrtc.org> Fri Feb 26 17:31:32 2016
committer Commit bot <commit-bot@chromium.org> Fri Feb 26 17:31:41 2016
tree 58b51f8ccff3f9d8f4db7aeafc672e3ed6297a9c
parent 9e69dfdfd5f38cdbd335280fb158a6e2a11a65d6

Don't allocate buffers for listening sockets.

Listening sockets will not read/write directly, so they don't need buffers.

BUG=

Review URL: https://codereview.webrtc.org/1737053006

Cr-Commit-Position: refs/heads/master@{#11791}

webrtc/base/asynctcpsocket.cc

diff --git a/webrtc/base/asynctcpsocket.cc b/webrtc/base/asynctcpsocket.cc
index 8e83cd1..7ec6dc8 100644
--- a/webrtc/base/asynctcpsocket.cc
+++ b/webrtc/base/asynctcpsocket.cc
@@ -13,6 +13,7 @@
 #include <string.h>
 
 #include "webrtc/base/byteorder.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 
@@ -56,10 +57,13 @@
       inpos_(0),
       outsize_(max_packet_size),
       outpos_(0) {
-  inbuf_ = new char[insize_];
-  outbuf_ = new char[outsize_];
+  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_]);
+  }
 
-  ASSERT(socket_.get() != NULL);
+  RTC_DCHECK(socket_.get() != NULL);
   socket_->SignalConnectEvent.connect(
       this, &AsyncTCPSocketBase::OnConnectEvent);
   socket_->SignalReadEvent.connect(this, &AsyncTCPSocketBase::OnReadEvent);
@@ -73,10 +77,7 @@
   }
 }
 
-AsyncTCPSocketBase::~AsyncTCPSocketBase() {
-  delete [] inbuf_;
-  delete [] outbuf_;
-}
+AsyncTCPSocketBase::~AsyncTCPSocketBase() {}
 
 SocketAddress AsyncTCPSocketBase::GetLocalAddress() const {
   return socket_->GetLocalAddress();
@@ -103,7 +104,7 @@
     case Socket::CS_CONNECTED:
       return STATE_CONNECTED;
     default:
-      ASSERT(false);
+      RTC_NOTREACHED();
       return STATE_CLOSED;
   }
 }
@@ -131,7 +132,7 @@
   if (addr == remote_address)
     return Send(pv, cb, options);
   // Remote address may be empty if there is a sudden network change.
-  ASSERT(remote_address.IsNil());
+  RTC_DCHECK(remote_address.IsNil());
   socket_->SetError(ENOTCONN);
   return -1;
 }
@@ -142,32 +143,35 @@
     return -1;
   }
 
-  memcpy(outbuf_ + outpos_, pv, cb);
+  RTC_DCHECK(outbuf_.get());
+  memcpy(outbuf_.get() + outpos_, pv, cb);
   outpos_ += cb;
 
   return FlushOutBuffer();
 }
 
 int AsyncTCPSocketBase::FlushOutBuffer() {
-  int res = socket_->Send(outbuf_, outpos_);
+  RTC_DCHECK(outbuf_.get());
+  int res = socket_->Send(outbuf_.get(), outpos_);
   if (res <= 0) {
     return res;
   }
   if (static_cast<size_t>(res) <= outpos_) {
     outpos_ -= res;
   } else {
-    ASSERT(false);
+    RTC_NOTREACHED();
     return -1;
   }
   if (outpos_ > 0) {
-    memmove(outbuf_, outbuf_ + res, outpos_);
+    memmove(outbuf_.get(), outbuf_.get() + res, outpos_);
   }
   return res;
 }
 
 void AsyncTCPSocketBase::AppendToOutBuffer(const void* pv, size_t cb) {
-  ASSERT(outpos_ + cb < outsize_);
-  memcpy(outbuf_ + outpos_, pv, cb);
+  RTC_DCHECK(outpos_ + cb < outsize_);
+  RTC_DCHECK(outbuf_.get());
+  memcpy(outbuf_.get() + outpos_, pv, cb);
   outpos_ += cb;
 }
 
@@ -176,7 +180,7 @@
 }
 
 void AsyncTCPSocketBase::OnReadEvent(AsyncSocket* socket) {
-  ASSERT(socket_.get() == socket);
+  RTC_DCHECK(socket_.get() == socket);
 
   if (listen_) {
     rtc::SocketAddress address;
@@ -193,7 +197,8 @@
     // Prime a read event in case data is waiting.
     new_socket->SignalReadEvent(new_socket);
   } else {
-    int len = socket_->Recv(inbuf_ + inpos_, insize_ - inpos_);
+    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()) {
@@ -204,18 +209,18 @@
 
     inpos_ += len;
 
-    ProcessInput(inbuf_, &inpos_);
+    ProcessInput(inbuf_.get(), &inpos_);
 
     if (inpos_ >= insize_) {
       LOG(LS_ERROR) << "input buffer overflow";
-      ASSERT(false);
+      RTC_NOTREACHED();
       inpos_ = 0;
     }
   }
 }
 
 void AsyncTCPSocketBase::OnWriteEvent(AsyncSocket* socket) {
-  ASSERT(socket_.get() == socket);
+  RTC_DCHECK(socket_.get() == socket);
 
   if (outpos_ > 0) {
     FlushOutBuffer();