Use base::MakeRefCounted instead of new to alloc net::IOBuffer instances.

This CL only handles the files in //remoting. The files in //net were
tackled in https://crrev.com/c/1188959. Parallel CLs will tackle other
directories.

net::IOBuffer is (thread-safe) ref-counted. Asides from improving the
ability to reason about instance ownership locally, creating instances
via base::MakeRefCounted makes it possible to use 1-based ref-counting
in the future (see base/memory/ref_counted.h).

This CL is mechanical, to avoid introducing any behavior changes. The
difficult cases will be tackled by follow-up CLs. The following
transformations were performed.

* new IOBufferType(args) => base::MakeRefCounted<IOBufferType>(args)
* new IOBufferType => base::MakeRefCounted<IOBufferType>()
* scoped_refptr x(base::MakeRefCounted<IOBufferType>(args)) =>
  scoped_refptr x = base::MakeRefCounted<IOBufferType>(args)
* scoped_refptr<IOBufferType>(base::MakeRefCounted<IOBufferType>(args)) =>

  base::MakeRefCounted<IOBufferType>(args)
* In comments: creates a new IOBufferType => creates an IOBufferType
  (so it wouldn't trigger future searches for "new BufferType")
* Instantiated static members in HttpResponseBodyDrainer,
  HttpNetworkTransaction, HttpProxyClientSocket, WritersTest,
  UDPSocketTest, TestDelegate, UDPSocketPerfTest
  (needed to fix linker errors)
* arraysize -> base::size (where needed to pass presubmit checks)
* git cl format

Change-Id: I4feed626ef76c0da3934748ea063ce317ce2ce86
Reviewed-on: https://chromium-review.googlesource.com/1200571Reviewed-by: Gary Kacmarcik <garykac@chromium.org>
Commit-Queue: Victor Costan <pwnall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#590079}

remoting/base/buffered_socket_writer_unittest.cc

@@ -107,8 +107,9 @@ class BufferedSocketWriterTest : public testing::Test {
     EXPECT_EQ(net::OK, socket_->Connect(net::CompletionCallback()));
 
     writer_.reset(new BufferedSocketWriter());
-    test_buffer_ = new net::IOBufferWithSize(kTestBufferSize);
-    test_buffer_2_ = new net::IOBufferWithSize(kTestBufferSize);
+    test_buffer_ = base::MakeRefCounted<net::IOBufferWithSize>(kTestBufferSize);
+    test_buffer_2_ =
+        base::MakeRefCounted<net::IOBufferWithSize>(kTestBufferSize);
     for (int i = 0; i < kTestBufferSize; ++i) {
       test_buffer_->data()[i] = rand() % 256;
       test_buffer_2_->data()[i] = rand() % 256;

remoting/base/compound_buffer.h

@@ -52,7 +52,7 @@ class CompoundBuffer {
                int size);
   void Prepend(const CompoundBuffer& buffer);
 
-  // Same as above, but creates new IOBuffer and copies the data.
+  // Same as above, but creates an IOBuffer and copies the data.
   void AppendCopyOf(const char* data, int data_size);
   void PrependCopyOf(const char* data, int data_size);
 
@@ -71,7 +71,7 @@ class CompoundBuffer {
   // Returns true if content is locked.
   bool locked() const { return locked_; }
 
-  // Creates new IOBufferWithSize object and copies all data into it.
+  // Creates an IOBufferWithSize object and copies all data into it.
   // Ownership of the result is given to the caller.
   scoped_refptr<net::IOBufferWithSize> ToIOBufferWithSize() const;
 

remoting/base/compound_buffer_unittest.cc

@@ -78,7 +78,7 @@ class CompoundBufferTest : public testing::Test {
 
  protected:
   void SetUp() override {
-    data_ = new IOBuffer(kDataSize);
+    data_ = base::MakeRefCounted<IOBuffer>(kDataSize);
     for (int i = 0; i < kDataSize; ++i) {
       data_->data()[i] = i;
     }

remoting/base/socket_reader.cc

@@ -37,7 +37,7 @@ void SocketReader::Init(net::Socket* socket,
 
 void SocketReader::DoRead() {
   while (true) {
-    read_buffer_ = new net::IOBuffer(kReadBufferSize);
+    read_buffer_ = base::MakeRefCounted<net::IOBuffer>(kReadBufferSize);
     int result = socket_->Read(
         read_buffer_.get(),
         kReadBufferSize,

remoting/client/plugin/pepper_packet_socket_factory.cc

@@ -159,11 +159,10 @@ class UdpPacketSocket : public rtc::AsyncPacketSocket {
   DISALLOW_COPY_AND_ASSIGN(UdpPacketSocket);
 };
 
-UdpPacketSocket::PendingPacket::PendingPacket(
-    const void* buffer,
-    int buffer_size,
-    const pp::NetAddress& address)
-    : data(new net::IOBufferWithSize(buffer_size)),
+UdpPacketSocket::PendingPacket::PendingPacket(const void* buffer,
+                                              int buffer_size,
+                                              const pp::NetAddress& address)
+    : data(base::MakeRefCounted<net::IOBufferWithSize>(buffer_size)),
       address(address),
       retried(true) {
   memcpy(data->data(), buffer, buffer_size);

remoting/host/security_key/security_key_socket.cc

@@ -31,7 +31,8 @@ SecurityKeySocket::SecurityKeySocket(std::unique_ptr<net::StreamSocket> socket,
                                      base::TimeDelta timeout,
                                      const base::Closure& timeout_callback)
     : socket_(std::move(socket)),
-      read_buffer_(new net::IOBufferWithSize(kRequestReadBufferLength)) {
+      read_buffer_(base::MakeRefCounted<net::IOBufferWithSize>(
+          kRequestReadBufferLength)) {
   timer_.reset(new base::OneShotTimer());
   timer_->Start(FROM_HERE, timeout, timeout_callback);
 }

remoting/host/token_validator_base.cc

@@ -91,7 +91,7 @@ TokenValidatorBase::TokenValidatorBase(
     : third_party_auth_config_(third_party_auth_config),
       token_scope_(token_scope),
       request_context_getter_(request_context_getter),
-      buffer_(new net::IOBuffer(kBufferSize)),
+      buffer_(base::MakeRefCounted<net::IOBuffer>(kBufferSize)),
       weak_factory_(this) {
   DCHECK(third_party_auth_config_.token_url.is_valid());
   DCHECK(third_party_auth_config_.token_validation_url.is_valid());

remoting/protocol/channel_multiplexer_unittest.cc

@@ -114,7 +114,7 @@ class ChannelMultiplexerTest : public testing::Test {
 
   scoped_refptr<net::IOBufferWithSize> CreateTestBuffer(int size) {
     scoped_refptr<net::IOBufferWithSize> result =
-        new net::IOBufferWithSize(size);
+        base::MakeRefCounted<net::IOBufferWithSize>(size);
     for (int i = 0; i< size; ++i) {
       result->data()[i] = rand() % 256;
     }

remoting/protocol/channel_socket_adapter_unittest.cc

@@ -59,7 +59,7 @@ class TransportChannelSocketAdapterTest : public testing::Test {
 
 // Verify that Read() returns net::ERR_IO_PENDING.
 TEST_F(TransportChannelSocketAdapterTest, Read) {
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(kBufferSize));
+  scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(kBufferSize);
 
   int result = target_->Recv(buffer.get(), kBufferSize, callback_);
   ASSERT_EQ(net::ERR_IO_PENDING, result);
@@ -71,7 +71,7 @@ TEST_F(TransportChannelSocketAdapterTest, Read) {
 
 // Verify that Read() after Close() returns error.
 TEST_F(TransportChannelSocketAdapterTest, ReadClose) {
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(kBufferSize));
+  scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(kBufferSize);
 
   int result = target_->Recv(buffer.get(), kBufferSize, callback_);
   ASSERT_EQ(net::ERR_IO_PENDING, result);
@@ -85,7 +85,8 @@ TEST_F(TransportChannelSocketAdapterTest, ReadClose) {
 
 // Verify that Send sends the packet and returns correct result.
 TEST_F(TransportChannelSocketAdapterTest, Send) {
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(kTestDataSize));
+  scoped_refptr<IOBuffer> buffer =
+      base::MakeRefCounted<IOBuffer>(kTestDataSize);
 
   EXPECT_CALL(channel_, SendPacket(buffer->data(), kTestDataSize, _, 0))
       .WillOnce(Return(kTestDataSize));
@@ -97,7 +98,8 @@ TEST_F(TransportChannelSocketAdapterTest, Send) {
 // Verify that the message is still sent if Send() is called while
 // socket is not open yet. The result is the packet is lost.
 TEST_F(TransportChannelSocketAdapterTest, SendPending) {
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(kTestDataSize));
+  scoped_refptr<IOBuffer> buffer =
+      base::MakeRefCounted<IOBuffer>(kTestDataSize);
 
   EXPECT_CALL(channel_, SendPacket(buffer->data(), kTestDataSize, _, 0))
       .Times(1)

remoting/protocol/chromium_socket_factory.cc

@@ -110,7 +110,7 @@ UdpPacketSocket::PendingPacket::PendingPacket(const void* buffer,
                                               int buffer_size,
                                               const net::IPEndPoint& address,
                                               const rtc::PacketOptions& options)
-    : data(new net::IOBufferWithSize(buffer_size)),
+    : data(base::MakeRefCounted<net::IOBufferWithSize>(buffer_size)),
       address(address),
       retried(false),
       options(options) {
@@ -339,7 +339,7 @@ void UdpPacketSocket::OnSendCompleted(int result) {
 void UdpPacketSocket::DoRead() {
   int result = 0;
   while (result >= 0) {
-    receive_buffer_ = new net::IOBuffer(kReceiveBufferSize);
+    receive_buffer_ = base::MakeRefCounted<net::IOBuffer>(kReceiveBufferSize);
     result = socket_->RecvFrom(
         receive_buffer_.get(),
         kReceiveBufferSize,

remoting/protocol/connection_tester.cc

@@ -66,7 +66,7 @@ void StreamConnectionTester::InitBuffers() {
     output_buffer_->data()[i] = static_cast<char>(i);
   }
 
-  input_buffer_ = new net::GrowableIOBuffer();
+  input_buffer_ = base::MakeRefCounted<net::GrowableIOBuffer>();
 }
 
 void StreamConnectionTester::DoWrite() {
@@ -183,7 +183,8 @@ void DatagramConnectionTester::DoWrite() {
     return;
   }
 
-  scoped_refptr<net::IOBuffer> packet(new net::IOBuffer(message_size_));
+  scoped_refptr<net::IOBuffer> packet(
+      base::MakeRefCounted<net::IOBuffer>(message_size_));
   for (int i = 0; i < message_size_; ++i) {
     packet->data()[i] = static_cast<char>(i);
   }
@@ -220,7 +221,7 @@ void DatagramConnectionTester::DoRead() {
   int result = 1;
   while (result > 0) {
     int kReadSize = message_size_ * 2;
-    read_buffer_ = new net::IOBuffer(kReadSize);
+    read_buffer_ = base::MakeRefCounted<net::IOBuffer>(kReadSize);
 
     result = host_socket_->Recv(
         read_buffer_.get(), kReadSize,

remoting/protocol/fake_authenticator.cc

@@ -42,7 +42,8 @@ void FakeChannelAuthenticator::SecureAndAuthenticate(
       // ordering deterministic.
       did_write_bytes_ = true;
     } else {
-      scoped_refptr<net::IOBuffer> write_buf = new net::IOBuffer(1);
+      scoped_refptr<net::IOBuffer> write_buf =
+          base::MakeRefCounted<net::IOBuffer>(1);
       write_buf->data()[0] = 0;
       int result = socket_->Write(
           write_buf.get(), 1,
@@ -56,7 +57,8 @@ void FakeChannelAuthenticator::SecureAndAuthenticate(
       }
     }
 
-    scoped_refptr<net::IOBuffer> read_buf = new net::IOBuffer(1);
+    scoped_refptr<net::IOBuffer> read_buf =
+        base::MakeRefCounted<net::IOBuffer>(1);
     int result =
         socket_->Read(read_buf.get(), 1,
                       base::Bind(&FakeChannelAuthenticator::OnAuthBytesRead,

remoting/protocol/message_decoder_unittest.cc

@@ -72,7 +72,8 @@ void SimulateReadSequence(const int read_sequence[], int sequence_size) {
     int read = std::min(size - pos, read_sequence[pos % sequence_size]);
 
     // And then prepare an IOBuffer for feeding it.
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(read);
     memcpy(buffer->data(), test_data + pos, read);
     decoder.AddData(buffer, read);
     while (true) {

remoting/protocol/message_reader.cc

@@ -51,7 +51,7 @@ void MessageReader::DoRead() {
   // have messages that we haven't finished processing yet.
   bool read_succeeded = true;
   while (read_succeeded && !closed_ && !read_pending_) {
-    read_buffer_ = new net::IOBuffer(kReadBufferSize);
+    read_buffer_ = base::MakeRefCounted<net::IOBuffer>(kReadBufferSize);
     int result = socket_->Read(
         read_buffer_.get(),
         kReadBufferSize,

remoting/protocol/message_serialization.cc

@@ -20,7 +20,8 @@ scoped_refptr<net::IOBufferWithSize> SerializeAndFrameMessage(
   // int32_t of the serialized message size for framing.
   const int kExtraBytes = sizeof(int32_t);
   int size = msg.ByteSize() + kExtraBytes;
-  scoped_refptr<net::IOBufferWithSize> buffer(new net::IOBufferWithSize(size));
+  scoped_refptr<net::IOBufferWithSize> buffer =
+      base::MakeRefCounted<net::IOBufferWithSize>(size);
   rtc::SetBE32(buffer->data(), msg.GetCachedSize());
   msg.SerializeWithCachedSizesToArray(
       reinterpret_cast<uint8_t*>(buffer->data()) + kExtraBytes);

remoting/protocol/pseudotcp_adapter.cc

@@ -338,7 +338,8 @@ cricket::IPseudoTcpNotify::WriteResult PseudoTcpAdapter::Core::TcpWritePacket(
   if (socket_write_pending_)
     return IPseudoTcpNotify::WR_SUCCESS;
 
-  scoped_refptr<net::IOBuffer> write_buffer = new net::IOBuffer(len);
+  scoped_refptr<net::IOBuffer> write_buffer =
+      base::MakeRefCounted<net::IOBuffer>(len);
   memcpy(write_buffer->data(), buffer, len);
 
   // Our underlying socket is datagram-oriented, which means it should either
@@ -365,7 +366,7 @@ cricket::IPseudoTcpNotify::WriteResult PseudoTcpAdapter::Core::TcpWritePacket(
 
 void PseudoTcpAdapter::Core::DoReadFromSocket() {
   if (!socket_read_buffer_.get())
-    socket_read_buffer_ = new net::IOBuffer(kReadBufferSize);
+    socket_read_buffer_ = base::MakeRefCounted<net::IOBuffer>(kReadBufferSize);
 
   int result = 1;
   while (socket_ && result > 0) {

remoting/protocol/pseudotcp_adapter_unittest.cc

@@ -209,7 +209,7 @@ class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> {
         base::MakeRefCounted<net::IOBuffer>(kTestDataSize), kTestDataSize);
     memset(output_buffer_->data(), 123, kTestDataSize);
 
-    input_buffer_ = new net::GrowableIOBuffer();
+    input_buffer_ = base::MakeRefCounted<net::GrowableIOBuffer>();
     // Always keep kMessageSize bytes available at the end of the input buffer.
     input_buffer_->SetCapacity(kMessageSize);
   }

remoting/protocol/ssl_hmac_channel_authenticator.cc

@@ -359,7 +359,7 @@ void SslHmacChannelAuthenticator::OnConnected(int result) {
       base::MakeRefCounted<net::StringIOBuffer>(auth_bytes), auth_bytes.size());
 
   // Read an incoming token.
-  auth_read_buf_ = new net::GrowableIOBuffer();
+  auth_read_buf_ = base::MakeRefCounted<net::GrowableIOBuffer>();
   auth_read_buf_->SetCapacity(kAuthDigestLength);
 
   // If WriteAuthenticationBytes() results in |done_callback_| being

remoting/signaling/xmpp_signal_strategy.cc

@@ -284,7 +284,7 @@ void XmppSignalStrategy::Core::SendMessage(const std::string& message) {
          tls_state_ == TlsState::CONNECTED);
 
   scoped_refptr<net::IOBufferWithSize> buffer =
-      new net::IOBufferWithSize(message.size());
+      base::MakeRefCounted<net::IOBufferWithSize>(message.size());
   memcpy(buffer->data(), message.data(), message.size());
 
   net::NetworkTrafficAnnotationTag traffic_annotation =
@@ -481,7 +481,7 @@ void XmppSignalStrategy::Core::ReadSocket() {
 
   while (socket_ && !read_pending_ && (tls_state_ == TlsState::NOT_REQUESTED ||
                                        tls_state_ == TlsState::CONNECTED)) {
-    read_buffer_ = new net::IOBuffer(kReadBufferSize);
+    read_buffer_ = base::MakeRefCounted<net::IOBuffer>(kReadBufferSize);
     int result = socket_->Read(
         read_buffer_.get(), kReadBufferSize,
         base::Bind(&Core::OnReadResult, base::Unretained(this)));

remoting/test/fake_socket_factory.cc

@@ -118,7 +118,8 @@ int FakeUdpSocket::Send(const void* data, size_t data_size,
 int FakeUdpSocket::SendTo(const void* data, size_t data_size,
                           const rtc::SocketAddress& address,
                           const rtc::PacketOptions& options) {
-  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(data_size);
+  scoped_refptr<net::IOBuffer> buffer =
+      base::MakeRefCounted<net::IOBuffer>(data_size);
   memcpy(buffer->data(), data, data_size);
   base::TimeTicks now = base::TimeTicks::Now();
   cricket::ApplyPacketOptions(reinterpret_cast<uint8_t*>(buffer->data()),