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

This CL only handles the files in //components. 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

Cq-Include-Trybots: luci.chromium.try:ios-simulator-cronet;master.tryserver.chromium.android:android_cronet_tester
Change-Id: If70c6373def9a2b46561af5c5ff7de55027d44fa
Reviewed-on: https://chromium-review.googlesource.com/1200415Reviewed-by: Sylvain Defresne <sdefresne@chromium.org>
Commit-Queue: Victor Costan <pwnall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#588436}

components/cast_channel/cast_framer_unittest.cc

@@ -30,7 +30,7 @@ class CastFramerTest : public testing::Test {
     cast_message_.set_payload_utf8("payload");
     ASSERT_TRUE(MessageFramer::Serialize(cast_message_, &cast_message_str_));
 
-    buffer_ = new net::GrowableIOBuffer;
+    buffer_ = base::MakeRefCounted<net::GrowableIOBuffer>();
     buffer_->SetCapacity(MessageFramer::MessageHeader::max_message_size());
     framer_.reset(new MessageFramer(buffer_.get()));
   }

components/cast_channel/cast_socket_unittest.cc

@@ -548,8 +548,8 @@ class SslCastSocketTest : public CastSocketTestBase {
   int ReadExactLength(net::IOBuffer* buffer,
                       int buffer_length,
                       net::Socket* socket) {
-    scoped_refptr<net::DrainableIOBuffer> draining_buffer(
-        new net::DrainableIOBuffer(buffer, buffer_length));
+    scoped_refptr<net::DrainableIOBuffer> draining_buffer =
+        base::MakeRefCounted<net::DrainableIOBuffer>(buffer, buffer_length);
     while (draining_buffer->BytesRemaining() > 0) {
       net::TestCompletionCallback read_callback;
       int read_result = read_callback.GetResult(server_socket_->Read(
@@ -564,8 +564,8 @@ class SslCastSocketTest : public CastSocketTestBase {
   int WriteExactLength(net::IOBuffer* buffer,
                        int buffer_length,
                        net::Socket* socket) {
-    scoped_refptr<net::DrainableIOBuffer> draining_buffer(
-        new net::DrainableIOBuffer(buffer, buffer_length));
+    scoped_refptr<net::DrainableIOBuffer> draining_buffer =
+        base::MakeRefCounted<net::DrainableIOBuffer>(buffer, buffer_length);
     while (draining_buffer->BytesRemaining() > 0) {
       net::TestCompletionCallback write_callback;
       int write_result = write_callback.GetResult(server_socket_->Write(
@@ -1069,8 +1069,8 @@ TEST_F(SslCastSocketTest, MAYBE_TestConnectEndToEndWithRealSSL) {
   EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str));
 
   int challenge_buffer_length = challenge_str.size();
-  scoped_refptr<net::IOBuffer> challenge_buffer(
-      new net::IOBuffer(challenge_buffer_length));
+  scoped_refptr<net::IOBuffer> challenge_buffer =
+      base::MakeRefCounted<net::IOBuffer>(challenge_buffer_length);
   int read = ReadExactLength(challenge_buffer.get(), challenge_buffer_length,
                              server_socket_.get());
 
@@ -1083,8 +1083,8 @@ TEST_F(SslCastSocketTest, MAYBE_TestConnectEndToEndWithRealSSL) {
   std::string reply_str;
   EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
 
-  scoped_refptr<net::StringIOBuffer> reply_buffer(
-      new net::StringIOBuffer(reply_str));
+  scoped_refptr<net::StringIOBuffer> reply_buffer =
+      base::MakeRefCounted<net::StringIOBuffer>(reply_str);
   int written = WriteExactLength(reply_buffer.get(), reply_buffer->size(),
                                  server_socket_.get());
 
@@ -1108,8 +1108,8 @@ TEST_F(SslCastSocketTest, DISABLED_TestMessageEndToEndWithRealSSL) {
   EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str));
 
   int challenge_buffer_length = challenge_str.size();
-  scoped_refptr<net::IOBuffer> challenge_buffer(
-      new net::IOBuffer(challenge_buffer_length));
+  scoped_refptr<net::IOBuffer> challenge_buffer =
+      base::MakeRefCounted<net::IOBuffer>(challenge_buffer_length);
 
   int read = ReadExactLength(challenge_buffer.get(), challenge_buffer_length,
                              server_socket_.get());
@@ -1123,8 +1123,8 @@ TEST_F(SslCastSocketTest, DISABLED_TestMessageEndToEndWithRealSSL) {
   std::string reply_str;
   EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
 
-  scoped_refptr<net::StringIOBuffer> reply_buffer(
-      new net::StringIOBuffer(reply_str));
+  scoped_refptr<net::StringIOBuffer> reply_buffer =
+      base::MakeRefCounted<net::StringIOBuffer>(reply_str);
   int written = WriteExactLength(reply_buffer.get(), reply_buffer->size(),
                                  server_socket_.get());
 
@@ -1141,8 +1141,8 @@ TEST_F(SslCastSocketTest, DISABLED_TestMessageEndToEndWithRealSSL) {
   EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str));
 
   int test_message_length = test_message_str.size();
-  scoped_refptr<net::IOBuffer> test_message_buffer(
-      new net::IOBuffer(test_message_length));
+  scoped_refptr<net::IOBuffer> test_message_buffer =
+      base::MakeRefCounted<net::IOBuffer>(test_message_length);
 
   EXPECT_CALL(handler_, OnWriteComplete(net::OK));
   socket_->transport()->SendMessage(

components/cast_channel/cast_transport.cc

@@ -44,7 +44,7 @@ CastTransportImpl::CastTransportImpl(Channel* channel,
 
   // Buffer is reused across messages to minimize unnecessary buffer
   // [re]allocations.
-  read_buffer_ = new net::GrowableIOBuffer();
+  read_buffer_ = base::MakeRefCounted<net::GrowableIOBuffer>();
   read_buffer_->SetCapacity(MessageFramer::MessageHeader::max_message_size());
   framer_.reset(new MessageFramer(read_buffer_));
 }

components/cronet/android/cronet_bidirectional_stream_adapter.cc

@@ -234,8 +234,9 @@ jboolean CronetBidirectionalStreamAdapter::WritevData(
     env->GetIntArrayRegion(pending_write_data->jwrite_buffer_limit_list.obj(),
                            i, 1, &limit);
     DCHECK_LE(pos, limit);
-    scoped_refptr<net::WrappedIOBuffer> write_buffer(
-        new net::WrappedIOBuffer(static_cast<char*>(data) + pos));
+    scoped_refptr<net::WrappedIOBuffer> write_buffer =
+        base::MakeRefCounted<net::WrappedIOBuffer>(static_cast<char*>(data) +
+                                                   pos);
     pending_write_data->write_buffer_list.push_back(write_buffer);
     pending_write_data->write_buffer_len_list.push_back(limit - pos);
   }

components/cronet/android/test/test_upload_data_stream_handler.cc

@@ -128,7 +128,7 @@ void TestUploadDataStreamHandler::ReadOnNetworkThread() {
   DCHECK(network_thread_->BelongsToCurrentThread());
   read_callback_invoked_ = false;
   if (!read_buffer_.get())
-    read_buffer_ = new net::IOBufferWithSize(kReadBufferSize);
+    read_buffer_ = base::MakeRefCounted<net::IOBufferWithSize>(kReadBufferSize);
 
   int bytes_read = upload_data_stream_->Read(
       read_buffer_.get(), kReadBufferSize,

components/domain_reliability/uploader_unittest.cc

@@ -71,7 +71,7 @@ class UploadMockURLRequestJob : public net::URLRequestJob {
     EXPECT_EQ(net::OK, rv);
 
     size_t upload_size = upload_stream_->size();
-    upload_buffer_ = new net::IOBufferWithSize(upload_size);
+    upload_buffer_ = base::MakeRefCounted<net::IOBufferWithSize>(upload_size);
     rv = upload_stream_->Read(
         upload_buffer_.get(), upload_size,
         base::BindOnce(&UploadMockURLRequestJob::OnStreamRead,

components/download/internal/background_service/in_memory_download_unittest.cc

@@ -126,7 +126,8 @@ class InMemoryDownloadTest : public testing::Test {
     DCHECK(blob);
     int bytes_read = 0;
     int async_bytes_read = 0;
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(expected.size()));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(expected.size());
 
     auto blob_reader = blob->CreateReader();
 

components/download/internal/common/download_file_unittest.cc

@@ -266,7 +266,8 @@ class DownloadFileTest : public testing::Test {
     for (size_t i = 0; i < num_chunks; i++) {
       const char* source_data = data_chunks[i];
       size_t length = strlen(source_data);
-      scoped_refptr<net::IOBuffer> data = new net::IOBuffer(length);
+      scoped_refptr<net::IOBuffer> data =
+          base::MakeRefCounted<net::IOBuffer>(length);
       memcpy(data->data(), source_data, length);
       EXPECT_CALL(*input_stream, Read(_, _))
           .InSequence(s)

components/download/internal/common/stream_handle_input_stream.cc

@@ -70,7 +70,7 @@ InputStream::StreamState StreamHandleInputStream::Read(
     return InputStream::EMPTY;
 
   *length = kBytesToRead;
-  *data = new net::IOBuffer(kBytesToRead);
+  *data = base::MakeRefCounted<net::IOBuffer>(kBytesToRead);
   MojoResult mojo_result = stream_handle_->stream->ReadData(
       (*data)->data(), (uint32_t*)length, MOJO_READ_DATA_FLAG_NONE);
   // TODO(qinmin): figure out when COMPLETE should be returned.

components/drive/chromeos/drive_test_util.h

@@ -48,7 +48,8 @@ struct DestroyHelperForTests {
 template<typename Reader>
 int ReadAllData(Reader* reader, std::string* content) {
   const int kBufferSize = 10;
-  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
+  scoped_refptr<net::IOBuffer> buffer =
+      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
   while (true) {
     net::TestCompletionCallback callback;
     int result = reader->Read(buffer.get(), kBufferSize, callback.callback());

components/grpc_support/bidirectional_stream.cc

@@ -109,8 +109,8 @@ int BidirectionalStream::Start(const char* url,
 bool BidirectionalStream::ReadData(char* buffer, int capacity) {
   if (!buffer)
     return false;
-  scoped_refptr<net::WrappedIOBuffer> read_buffer(
-      new net::WrappedIOBuffer(buffer));
+  scoped_refptr<net::WrappedIOBuffer> read_buffer =
+      base::MakeRefCounted<net::WrappedIOBuffer>(buffer);
 
   PostToNetworkThread(
       FROM_HERE, base::BindOnce(&BidirectionalStream::ReadDataOnNetworkThread,
@@ -124,8 +124,8 @@ bool BidirectionalStream::WriteData(const char* buffer,
   if (!buffer)
     return false;
 
-  scoped_refptr<net::WrappedIOBuffer> write_buffer(
-      new net::WrappedIOBuffer(buffer));
+  scoped_refptr<net::WrappedIOBuffer> write_buffer =
+      base::MakeRefCounted<net::WrappedIOBuffer>(buffer);
 
   PostToNetworkThread(
       FROM_HERE,

components/pairing/message_buffer_unittest.cc

@@ -13,7 +13,8 @@ typedef testing::Test MessageBufferTest;
 
 TEST_F(MessageBufferTest, BasicReadWrite) {
   MessageBuffer message_buffer;
-  scoped_refptr<net::IOBuffer> io_buffer(new net::IOBuffer(3));
+  scoped_refptr<net::IOBuffer> io_buffer =
+      base::MakeRefCounted<net::IOBuffer>(3);
   io_buffer->data()[0] = 3;
   io_buffer->data()[1] = 1;
   io_buffer->data()[2] = 4;
@@ -35,10 +36,12 @@ TEST_F(MessageBufferTest, BasicReadWrite) {
 
 TEST_F(MessageBufferTest, SplitBuffer) {
   MessageBuffer message_buffer;
-  scoped_refptr<net::IOBuffer> io_buffer0(new net::IOBuffer(1));
+  scoped_refptr<net::IOBuffer> io_buffer0 =
+      base::MakeRefCounted<net::IOBuffer>(1);
   io_buffer0->data()[0] = 3;
 
-  scoped_refptr<net::IOBuffer> io_buffer1(new net::IOBuffer(2));
+  scoped_refptr<net::IOBuffer> io_buffer1 =
+      base::MakeRefCounted<net::IOBuffer>(2);
   io_buffer1->data()[0] = 1;
   io_buffer1->data()[1] = 4;
 
@@ -56,11 +59,14 @@ TEST_F(MessageBufferTest, SplitBuffer) {
 
 TEST_F(MessageBufferTest, EmptyBuffer) {
   MessageBuffer message_buffer;
-  scoped_refptr<net::IOBuffer> io_buffer0(new net::IOBuffer(1));
+  scoped_refptr<net::IOBuffer> io_buffer0 =
+      base::MakeRefCounted<net::IOBuffer>(1);
   io_buffer0->data()[0] = 3;
 
-  scoped_refptr<net::IOBuffer> io_buffer1(new net::IOBuffer(0));
-  scoped_refptr<net::IOBuffer> io_buffer2(new net::IOBuffer(2));
+  scoped_refptr<net::IOBuffer> io_buffer1 =
+      base::MakeRefCounted<net::IOBuffer>(0);
+  scoped_refptr<net::IOBuffer> io_buffer2 =
+      base::MakeRefCounted<net::IOBuffer>(2);
   io_buffer2->data()[0] = 1;
   io_buffer2->data()[1] = 4;
 

components/pairing/proto_decoder.cc

@@ -204,7 +204,7 @@ ProtoDecoder::IOBufferRefPtr ProtoDecoder::SendMessage(
   uint16_t message_size = message.size();
 
   *size = sizeof(message_type) + sizeof(message_size) + message.size();
-  IOBufferRefPtr io_buffer(new net::IOBuffer(*size));
+  IOBufferRefPtr io_buffer = base::MakeRefCounted<net::IOBuffer>(*size);
 
   // Write the message type.
   int offset = 0;