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

This CL only handles the files in //chrome. 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: Ia77ede36d452982213f01b953d0e579e97889738
Reviewed-on: https://chromium-review.googlesource.com/1200413Reviewed-by: Lei Zhang <thestig@chromium.org>
Commit-Queue: Victor Costan <pwnall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#588273}

chrome/browser/chromeos/arc/fileapi/file_stream_forwarder.cc

@@ -42,7 +42,7 @@ FileStreamForwarder::FileStreamForwarder(
                            // completion of tasks running with this task runner.
                            {base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN,
                             base::MayBlock()})),
-      buf_(new net::IOBufferWithSize(kBufSize)),
+      buf_(base::MakeRefCounted<net::IOBufferWithSize>(kBufSize)),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(

chrome/browser/chromeos/drive/drive_file_stream_reader_unittest.cc

@@ -119,7 +119,8 @@ TEST_F(NetworkReaderProxyTest, EmptyFile) {
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 10;
-  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
+  scoped_refptr<net::IOBuffer> buffer =
+      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 
   // For empty file, Read() should return 0 immediately.
@@ -134,7 +135,8 @@ TEST_F(NetworkReaderProxyTest, Read) {
 
     net::TestCompletionCallback callback;
     const int kBufferSize = 3;
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(kBufferSize);
 
     // If no data is available yet, ERR_IO_PENDING should be returned.
     int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
@@ -184,7 +186,8 @@ TEST_F(NetworkReaderProxyTest, ReadWithLimit) {
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 3;
-  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
+  scoped_refptr<net::IOBuffer> buffer =
+      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
 
   // If no data is available yet, ERR_IO_PENDING should be returned.
   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
@@ -233,7 +236,8 @@ TEST_F(NetworkReaderProxyTest, ErrorWithPendingCallback) {
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 3;
-  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
+  scoped_refptr<net::IOBuffer> buffer =
+      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
 
   // Set pending callback.
   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
@@ -254,7 +258,8 @@ TEST_F(NetworkReaderProxyTest, ErrorWithPendingData) {
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 3;
-  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
+  scoped_refptr<net::IOBuffer> buffer =
+      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
 
   // Supply the data before an error.
   std::unique_ptr<std::string> data(new std::string("abcde"));

chrome/browser/chromeos/drive/fileapi/webkit_file_stream_reader_impl_unittest.cc

@@ -143,7 +143,8 @@ TEST_F(WebkitFileStreamReaderImplTest, ReadError) {
           base::Time()));  // expected modification time
 
   const int kBufferSize = 10;
-  scoped_refptr<net::IOBuffer> io_buffer(new net::IOBuffer(kBufferSize));
+  scoped_refptr<net::IOBuffer> io_buffer =
+      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
   net::TestCompletionCallback callback;
   int result = reader->Read(io_buffer.get(), kBufferSize, callback.callback());
   result = callback.GetResult(result);

chrome/browser/chromeos/extensions/file_manager/file_stream_md5_digester.cc

@@ -20,7 +20,7 @@ const int kMd5DigestBufferSize = 512 * 1024;  // 512 kB.
 }  // namespace
 
 FileStreamMd5Digester::FileStreamMd5Digester()
-    : buffer_(new net::IOBuffer(kMd5DigestBufferSize)) {}
+    : buffer_(base::MakeRefCounted<net::IOBuffer>(kMd5DigestBufferSize)) {}
 
 FileStreamMd5Digester::~FileStreamMd5Digester() = default;
 

chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader.cc

@@ -22,7 +22,8 @@ BufferingFileStreamReader::BufferingFileStreamReader(
       preloading_buffer_length_(preloading_buffer_length),
       max_bytes_to_read_(max_bytes_to_read),
       bytes_read_(0),
-      preloading_buffer_(new net::IOBuffer(preloading_buffer_length)),
+      preloading_buffer_(
+          base::MakeRefCounted<net::IOBuffer>(preloading_buffer_length)),
       preloading_buffer_offset_(0),
       preloaded_bytes_(0),
       weak_ptr_factory_(this) {}

chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader_unittest.cc

@@ -101,7 +101,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
   // For the first read, the internal file stream reader is fired, as there is
   // no data in the preloading buffer.
   {
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));
@@ -118,7 +119,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
   // the internal file stream reader.
   {
     inner_read_log.clear();
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));
@@ -134,7 +136,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
   // valid to return less bytes than requested.
   {
     inner_read_log.clear();
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));
@@ -150,7 +153,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
   // file stream reader.
   {
     inner_read_log.clear();
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));
@@ -173,7 +177,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) {
 
   // First read couple of bytes, so the internal buffer is filled out.
   {
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));
@@ -193,7 +198,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) {
   // as much as available in the internal buffer.
   {
     inner_read_log.clear();
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(read_bytes);
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), read_bytes, base::Bind(&LogValue<int>, &read_log));
@@ -209,7 +215,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) {
   // the internal buffer.
   {
     inner_read_log.clear();
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(read_bytes);
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), read_bytes, base::Bind(&LogValue<int>, &read_log));
@@ -232,7 +239,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
       kPreloadingBufferLength, kFileSize);
   // First read couple of bytes, so the internal buffer is filled out.
   {
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));
@@ -251,7 +259,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
     inner_read_log.clear();
     const int chunk_size = 20;
     ASSERT_LT(kPreloadingBufferLength, chunk_size);
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(chunk_size));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(chunk_size);
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), chunk_size, base::Bind(&LogValue<int>, &read_log));
@@ -279,7 +288,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
   ASSERT_LT(read_bytes, kPreloadingBufferLength);
   ASSERT_LE(read_bytes, total_bytes_to_read);
 
-  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes));
+  scoped_refptr<net::IOBuffer> buffer =
+      base::MakeRefCounted<net::IOBuffer>(read_bytes);
   std::vector<int> read_log;
   const int result = reader.Read(
       buffer.get(), read_bytes, base::Bind(&LogValue<int>, &read_log));
@@ -305,7 +315,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
   const int read_bytes = 2;
   ASSERT_LT(read_bytes, kPreloadingBufferLength);
 
-  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes));
+  scoped_refptr<net::IOBuffer> buffer =
+      base::MakeRefCounted<net::IOBuffer>(read_bytes);
   std::vector<int> read_log;
   const int result = reader.Read(
       buffer.get(), read_bytes, base::Bind(&LogValue<int>, &read_log));
@@ -325,7 +336,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_WithError) {
           new FakeFileStreamReader(&inner_read_log, net::ERR_ACCESS_DENIED)),
       kPreloadingBufferLength, kFileSize);
 
-  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
+  scoped_refptr<net::IOBuffer> buffer =
+      base::MakeRefCounted<net::IOBuffer>(kChunkSize);
   std::vector<int> read_log;
   const int result = reader.Read(
       buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));

chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_writer.cc

@@ -18,7 +18,8 @@ BufferingFileStreamWriter::BufferingFileStreamWriter(
     int intermediate_buffer_length)
     : file_stream_writer_(std::move(file_stream_writer)),
       intermediate_buffer_length_(intermediate_buffer_length),
-      intermediate_buffer_(new net::IOBuffer(intermediate_buffer_length_)),
+      intermediate_buffer_(
+          base::MakeRefCounted<net::IOBuffer>(intermediate_buffer_length_)),
       buffered_bytes_(0),
       weak_ptr_factory_(this) {}
 

chrome/browser/chromeos/file_system_provider/fileapi/file_stream_reader_unittest.cc

@@ -132,8 +132,8 @@ TEST_F(FileSystemProviderFileStreamReader, Read_AllAtOnce) {
   const int64_t initial_offset = 0;
   FileStreamReader reader(NULL, file_url_, initial_offset,
                           *fake_file_->metadata->modification_time);
-  scoped_refptr<net::IOBuffer> io_buffer(new net::IOBuffer(
-      base::checked_cast<size_t>(*fake_file_->metadata->size)));
+  scoped_refptr<net::IOBuffer> io_buffer = base::MakeRefCounted<net::IOBuffer>(
+      base::checked_cast<size_t>(*fake_file_->metadata->size));
 
   const int result =
       reader.Read(io_buffer.get(), *fake_file_->metadata->size,
@@ -155,8 +155,8 @@ TEST_F(FileSystemProviderFileStreamReader, Read_WrongFile) {
   const int64_t initial_offset = 0;
   FileStreamReader reader(NULL, wrong_file_url_, initial_offset,
                           *fake_file_->metadata->modification_time);
-  scoped_refptr<net::IOBuffer> io_buffer(new net::IOBuffer(
-      base::checked_cast<size_t>(*fake_file_->metadata->size)));
+  scoped_refptr<net::IOBuffer> io_buffer = base::MakeRefCounted<net::IOBuffer>(
+      base::checked_cast<size_t>(*fake_file_->metadata->size));
 
   const int result =
       reader.Read(io_buffer.get(), *fake_file_->metadata->size,
@@ -176,7 +176,8 @@ TEST_F(FileSystemProviderFileStreamReader, Read_InChunks) {
                           *fake_file_->metadata->modification_time);
 
   for (int64_t offset = 0; offset < *fake_file_->metadata->size; ++offset) {
-    scoped_refptr<net::IOBuffer> io_buffer(new net::IOBuffer(1));
+    scoped_refptr<net::IOBuffer> io_buffer =
+        base::MakeRefCounted<net::IOBuffer>(1);
     const int result =
         reader.Read(io_buffer.get(),
                     1,
@@ -200,7 +201,8 @@ TEST_F(FileSystemProviderFileStreamReader, Read_Slice) {
 
   FileStreamReader reader(NULL, file_url_, initial_offset,
                           *fake_file_->metadata->modification_time);
-  scoped_refptr<net::IOBuffer> io_buffer(new net::IOBuffer(length));
+  scoped_refptr<net::IOBuffer> io_buffer =
+      base::MakeRefCounted<net::IOBuffer>(length);
 
   const int result =
       reader.Read(io_buffer.get(),
@@ -227,7 +229,8 @@ TEST_F(FileSystemProviderFileStreamReader, Read_Beyond) {
 
   FileStreamReader reader(NULL, file_url_, initial_offset,
                           *fake_file_->metadata->modification_time);
-  scoped_refptr<net::IOBuffer> io_buffer(new net::IOBuffer(length));
+  scoped_refptr<net::IOBuffer> io_buffer =
+      base::MakeRefCounted<net::IOBuffer>(length);
 
   const int result =
       reader.Read(io_buffer.get(),
@@ -250,8 +253,8 @@ TEST_F(FileSystemProviderFileStreamReader, Read_ModifiedFile) {
   const int64_t initial_offset = 0;
   FileStreamReader reader(NULL, file_url_, initial_offset, base::Time::Max());
 
-  scoped_refptr<net::IOBuffer> io_buffer(new net::IOBuffer(
-      base::checked_cast<size_t>(*fake_file_->metadata->size)));
+  scoped_refptr<net::IOBuffer> io_buffer = base::MakeRefCounted<net::IOBuffer>(
+      base::checked_cast<size_t>(*fake_file_->metadata->size));
   const int result =
       reader.Read(io_buffer.get(), *fake_file_->metadata->size,
                   base::Bind(&EventLogger::OnRead, logger.GetWeakPtr()));
@@ -269,8 +272,8 @@ TEST_F(FileSystemProviderFileStreamReader, Read_ExpectedModificationTimeNull) {
   const int64_t initial_offset = 0;
   FileStreamReader reader(NULL, file_url_, initial_offset, base::Time());
 
-  scoped_refptr<net::IOBuffer> io_buffer(new net::IOBuffer(
-      base::checked_cast<size_t>(*fake_file_->metadata->size)));
+  scoped_refptr<net::IOBuffer> io_buffer = base::MakeRefCounted<net::IOBuffer>(
+      base::checked_cast<size_t>(*fake_file_->metadata->size));
   const int result =
       reader.Read(io_buffer.get(), *fake_file_->metadata->size,
                   base::Bind(&EventLogger::OnRead, logger.GetWeakPtr()));

chrome/browser/chromeos/file_system_provider/fileapi/file_stream_writer_unittest.cc

@@ -109,7 +109,8 @@ TEST_F(FileSystemProviderFileStreamWriter, Write) {
 
   const int64_t initial_offset = 0;
   FileStreamWriter writer(file_url_, initial_offset);
-  scoped_refptr<net::IOBuffer> io_buffer(new net::StringIOBuffer(kTextToWrite));
+  scoped_refptr<net::IOBuffer> io_buffer =
+      base::MakeRefCounted<net::StringIOBuffer>(kTextToWrite);
 
   {
     const int result = writer.Write(io_buffer.get(),
@@ -160,7 +161,8 @@ TEST_F(FileSystemProviderFileStreamWriter, Cancel) {
 
   const int64_t initial_offset = 0;
   FileStreamWriter writer(file_url_, initial_offset);
-  scoped_refptr<net::IOBuffer> io_buffer(new net::StringIOBuffer(kTextToWrite));
+  scoped_refptr<net::IOBuffer> io_buffer =
+      base::MakeRefCounted<net::StringIOBuffer>(kTextToWrite);
 
   const int write_result = writer.Write(io_buffer.get(),
                                         sizeof(kTextToWrite) - 1,
@@ -182,7 +184,8 @@ TEST_F(FileSystemProviderFileStreamWriter, Cancel_NotRunning) {
 
   const int64_t initial_offset = 0;
   FileStreamWriter writer(file_url_, initial_offset);
-  scoped_refptr<net::IOBuffer> io_buffer(new net::StringIOBuffer(kTextToWrite));
+  scoped_refptr<net::IOBuffer> io_buffer =
+      base::MakeRefCounted<net::StringIOBuffer>(kTextToWrite);
 
   std::vector<int> cancel_log;
   const int cancel_result = writer.Cancel(base::Bind(&LogValue, &cancel_log));
@@ -198,7 +201,8 @@ TEST_F(FileSystemProviderFileStreamWriter, Write_WrongFile) {
 
   const int64_t initial_offset = 0;
   FileStreamWriter writer(wrong_file_url_, initial_offset);
-  scoped_refptr<net::IOBuffer> io_buffer(new net::StringIOBuffer(kTextToWrite));
+  scoped_refptr<net::IOBuffer> io_buffer =
+      base::MakeRefCounted<net::StringIOBuffer>(kTextToWrite);
 
   const int result = writer.Write(io_buffer.get(),
                                   sizeof(kTextToWrite) - 1,
@@ -222,7 +226,8 @@ TEST_F(FileSystemProviderFileStreamWriter, Write_Append) {
   ASSERT_LT(0, initial_offset);
 
   FileStreamWriter writer(file_url_, initial_offset);
-  scoped_refptr<net::IOBuffer> io_buffer(new net::StringIOBuffer(kTextToWrite));
+  scoped_refptr<net::IOBuffer> io_buffer =
+      base::MakeRefCounted<net::StringIOBuffer>(kTextToWrite);
 
   const int result = writer.Write(io_buffer.get(),
                                   sizeof(kTextToWrite) - 1,

chrome/browser/devtools/device/adb/adb_client_socket.cc

@@ -202,7 +202,7 @@ void AdbClientSocket::SendCommand(const std::string& command,
                                   bool is_void,
                                   const CommandCallback& callback) {
   scoped_refptr<net::StringIOBuffer> request_buffer =
-      new net::StringIOBuffer(EncodeMessage(command));
+      base::MakeRefCounted<net::StringIOBuffer>(EncodeMessage(command));
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("adb_client_socket", R"(
         semantics {
@@ -243,7 +243,7 @@ void AdbClientSocket::ReadResponse(const CommandCallback& callback,
     return;
   }
   scoped_refptr<net::IOBuffer> response_buffer =
-      new net::IOBuffer(kBufferSize);
+      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
   result = socket_->Read(response_buffer.get(),
                          kBufferSize,
                          base::Bind(&AdbClientSocket::OnResponseHeader,

chrome/browser/devtools/device/adb/mock_adb_server.cc

@@ -253,10 +253,10 @@ SimpleHttpServer::~SimpleHttpServer() {
 SimpleHttpServer::Connection::Connection(net::StreamSocket* socket,
                                          const ParserFactory& factory)
     : socket_(socket),
-      parser_(factory.Run(base::Bind(&Connection::Send,
-                                     base::Unretained(this)))),
-      input_buffer_(new net::GrowableIOBuffer()),
-      output_buffer_(new net::GrowableIOBuffer()),
+      parser_(
+          factory.Run(base::Bind(&Connection::Send, base::Unretained(this)))),
+      input_buffer_(base::MakeRefCounted<net::GrowableIOBuffer>()),
+      output_buffer_(base::MakeRefCounted<net::GrowableIOBuffer>()),
       bytes_to_write_(0),
       read_closed_(false),
       weak_factory_(this) {

chrome/browser/devtools/device/android_device_manager.cc

@@ -203,7 +203,7 @@ class HttpRequest {
     if (!CheckNetResultOrDie(result))
       return;
 
-    response_buffer_ = new net::IOBuffer(kBufferSize);
+    response_buffer_ = base::MakeRefCounted<net::IOBuffer>(kBufferSize);
 
     result = socket_->Read(
         response_buffer_.get(),

chrome/browser/devtools/device/android_web_socket.cc

@@ -72,7 +72,8 @@ class AndroidDeviceManager::AndroidWebSocket::WebSocketImpl {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(socket_);
 
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(kBufferSize);
 
     if (response_buffer_.size() > 0)
       ProcessResponseBuffer(buffer);
@@ -156,7 +157,7 @@ class AndroidDeviceManager::AndroidWebSocket::WebSocketImpl {
       return;
 
     scoped_refptr<net::StringIOBuffer> buffer =
-        new net::StringIOBuffer(request_buffer_);
+        base::MakeRefCounted<net::StringIOBuffer>(request_buffer_);
     result = socket_->Write(buffer.get(), buffer->size(),
                             base::Bind(&WebSocketImpl::SendPendingRequests,
                                        weak_factory_.GetWeakPtr()),

chrome/browser/devtools/device/port_forwarding_controller.cc

@@ -213,7 +213,8 @@ class SocketTunnel : public network::mojom::ResolveHostClient {
   }
 
   void Pump(net::StreamSocket* from, net::StreamSocket* to) {
-    scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kBufferSize);
+    scoped_refptr<net::IOBuffer> buffer =
+        base::MakeRefCounted<net::IOBuffer>(kBufferSize);
     int result = from->Read(
         buffer.get(),
         kBufferSize,

chrome/browser/devtools/device/usb/usb_device_provider.cc

@@ -57,7 +57,8 @@ void OpenedForCommand(const UsbDeviceProvider::CommandCallback& callback,
     callback.Run(result, std::string());
     return;
   }
-  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kBufferSize);
+  scoped_refptr<net::IOBuffer> buffer =
+      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
   result = socket->Read(
       buffer.get(),
       kBufferSize,

chrome/browser/extensions/api/messaging/native_message_process_host.cc

@@ -164,7 +164,8 @@ void NativeMessageProcessHost::OnMessage(const std::string& json) {
 
   // Allocate new buffer for the message.
   scoped_refptr<net::IOBufferWithSize> buffer =
-      new net::IOBufferWithSize(json.size() + kMessageHeaderSize);
+      base::MakeRefCounted<net::IOBufferWithSize>(json.size() +
+                                                  kMessageHeaderSize);
 
   // Copy size and content of the message to the buffer.
   static_assert(sizeof(uint32_t) == kMessageHeaderSize,
@@ -223,7 +224,7 @@ void NativeMessageProcessHost::DoRead() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   while (!closed_ && !read_pending_) {
-    read_buffer_ = new net::IOBuffer(kReadBufferSize);
+    read_buffer_ = base::MakeRefCounted<net::IOBuffer>(kReadBufferSize);
     int result =
         read_stream_->Read(read_buffer_.get(), kReadBufferSize,
                            base::BindOnce(&NativeMessageProcessHost::OnRead,

chrome/browser/extensions/api/socket/udp_socket_unittest.cc

@@ -140,7 +140,8 @@ static void SendMulticastPacket(const base::Closure& quit_run_loop,
                                 UDPSocket* src,
                                 int result) {
   if (result == 0) {
-    scoped_refptr<net::IOBuffer> data = new net::WrappedIOBuffer(kTestMessage);
+    scoped_refptr<net::IOBuffer> data =
+        base::MakeRefCounted<net::WrappedIOBuffer>(kTestMessage);
     src->Write(data, kTestMessageLength, base::BindRepeating(&OnSendCompleted));
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,

chrome/browser/media/router/discovery/dial/dial_service.cc

@@ -194,7 +194,7 @@ bool DialServiceImpl::DialSocket::CreateAndBindSocket(
     return false;
   }
 
-  recv_buffer_ = new IOBufferWithSize(kDialRecvBufferSize);
+  recv_buffer_ = base::MakeRefCounted<IOBufferWithSize>(kDialRecvBufferSize);
   return ReadSocket();
 }
 
@@ -396,7 +396,7 @@ DialServiceImpl::DialServiceImpl(net::NetLog* net_log)
   bool success = address.AssignFromIPLiteral(kDialRequestAddress);
   DCHECK(success);
   send_address_ = net::IPEndPoint(address, kDialRequestPort);
-  send_buffer_ = new StringIOBuffer(BuildRequest());
+  send_buffer_ = base::MakeRefCounted<StringIOBuffer>(BuildRequest());
 }
 
 DialServiceImpl::~DialServiceImpl() {

chrome/browser/media/router/discovery/dial/dial_service_unittest.cc

@@ -139,7 +139,8 @@ TEST_F(DialServiceTest, TestNotifyOnError) {
 TEST_F(DialServiceTest, TestOnDeviceDiscovered) {
   dial_service_.discovery_active_ = true;
   int response_size = arraysize(kValidResponse) - 1;
-  dial_socket_->recv_buffer_ = new net::IOBufferWithSize(response_size);
+  dial_socket_->recv_buffer_ =
+      base::MakeRefCounted<net::IOBufferWithSize>(response_size);
   strncpy(dial_socket_->recv_buffer_->data(), kValidResponse, response_size);
   dial_socket_->recv_address_ = net::IPEndPoint(mock_ip_, 12345);
 

chrome/browser/media_galleries/fileapi/mtp_file_stream_reader.cc

@@ -61,7 +61,7 @@ int MTPFileStreamReader::Read(net::IOBuffer* buf,
       header_buf_len = buf_len;
     } else {
       // Otherwise, make a special request for the header.
-      header_buf = new net::IOBuffer(net::kMaxBytesToSniff);
+      header_buf = base::MakeRefCounted<net::IOBuffer>(net::kMaxBytesToSniff);
       header_buf_len = net::kMaxBytesToSniff;
     }
 

chrome/browser/media_galleries/fileapi/readahead_file_stream_reader.cc

@@ -40,7 +40,7 @@ int ReadaheadFileStreamReader::Read(net::IOBuffer* buf,
   ReadFromSourceIfNeeded();
 
   scoped_refptr<net::DrainableIOBuffer> sink =
-      new net::DrainableIOBuffer(buf, buf_len);
+      base::MakeRefCounted<net::DrainableIOBuffer>(buf, buf_len);
   int result = FinishReadFromCacheOrStoredError(sink.get());
 
   // We are waiting for an source read to complete, so save the request.
@@ -104,7 +104,8 @@ void ReadaheadFileStreamReader::ReadFromSourceIfNeeded() {
 
   source_has_pending_read_ = true;
 
-  scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kBufferSize));
+  scoped_refptr<net::IOBuffer> buf =
+      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
   int result = source_->Read(
       buf.get(), kBufferSize,
       base::Bind(&ReadaheadFileStreamReader::OnFinishReadFromSource,
@@ -122,8 +123,8 @@ void ReadaheadFileStreamReader::OnFinishReadFromSource(net::IOBuffer* buf,
 
   // Either store the data read from |source_|, or store the error code.
   if (result > 0) {
-    scoped_refptr<net::DrainableIOBuffer> drainable_buffer(
-        new net::DrainableIOBuffer(buf, result));
+    scoped_refptr<net::DrainableIOBuffer> drainable_buffer =
+        base::MakeRefCounted<net::DrainableIOBuffer>(buf, result);
     buffers_.push(drainable_buffer);
     ReadFromSourceIfNeeded();
   } else {

chrome/browser/offline_pages/offline_page_request_handler.cc

@@ -872,7 +872,7 @@ void OfflinePageRequestHandler::DidOpenForValidation(int result) {
   }
 
   if (!buffer_)
-    buffer_ = new net::IOBuffer(kMaxBufferSizeForValidation);
+    buffer_ = base::MakeRefCounted<net::IOBuffer>(kMaxBufferSizeForValidation);
 
   ReadForValidation();
 }

chrome/browser/offline_pages/offline_page_request_handler_unittest.cc

@@ -124,7 +124,7 @@ class TestURLRequestDelegate : public net::URLRequest::Delegate {
 
   explicit TestURLRequestDelegate(const ReadCompletedCallback& callback)
       : read_completed_callback_(callback),
-        buffer_(new net::IOBuffer(kBufSize)),
+        buffer_(base::MakeRefCounted<net::IOBuffer>(kBufSize)),
         request_status_(net::ERR_IO_PENDING) {}
 
   void OnResponseStarted(net::URLRequest* request, int net_error) override {

chrome/test/chromedriver/net/adb_client_socket.cc

@@ -155,7 +155,7 @@ class HttpOverAdbSocket {
     socket_.reset(socket);
 
     scoped_refptr<net::StringIOBuffer> request_buffer =
-        new net::StringIOBuffer(request_);
+        base::MakeRefCounted<net::StringIOBuffer>(request_);
 
     result = socket_->Write(
         request_buffer.get(), request_buffer->size(),
@@ -170,7 +170,7 @@ class HttpOverAdbSocket {
       return;
 
     scoped_refptr<net::IOBuffer> response_buffer =
-        new net::IOBuffer(kBufferSize);
+        base::MakeRefCounted<net::IOBuffer>(kBufferSize);
 
     result = socket_->Read(response_buffer.get(),
                            kBufferSize,
@@ -416,7 +416,7 @@ class AdbSendFileSocket : AdbClientSocket {
       buffer.append(payload, payloadLength);
 
     scoped_refptr<net::StringIOBuffer> request_buffer =
-        new net::StringIOBuffer(buffer);
+        base::MakeRefCounted<net::StringIOBuffer>(buffer);
     int result = socket_->Write(request_buffer.get(), request_buffer->size(),
                                 callback, TRAFFIC_ANNOTATION_FOR_TESTS);
     if (result != net::ERR_IO_PENDING)
@@ -535,7 +535,7 @@ void AdbClientSocket::SendCommand(const std::string& command,
                                   bool has_length,
                                   const CommandCallback& response_callback) {
   scoped_refptr<net::StringIOBuffer> request_buffer =
-      new net::StringIOBuffer(EncodeMessage(command));
+      base::MakeRefCounted<net::StringIOBuffer>(EncodeMessage(command));
   int result = socket_->Write(
       request_buffer.get(), request_buffer->size(),
       base::Bind(&AdbClientSocket::ReadResponse, base::Unretained(this),
@@ -554,7 +554,7 @@ void AdbClientSocket::ReadResponse(const CommandCallback& response_callback,
     return;
   }
   scoped_refptr<net::GrowableIOBuffer> socket_buffer =
-      new net::GrowableIOBuffer;
+      base::MakeRefCounted<net::GrowableIOBuffer>();
   socket_buffer->SetCapacity(kBufferSize);
   if (has_output) {
     const ParserCallback& parse_output_callback = base::Bind(

chrome/test/chromedriver/net/adb_client_socket_unittest.cc

@@ -99,7 +99,8 @@ class AdbClientSocketTest : public testing::Test {
     // The following means "expect not to be called."
     EXPECT_CALL(response_callback, Run(0, "")).Times(0);
 
-    scoped_refptr<net::GrowableIOBuffer> buffer = new net::GrowableIOBuffer;
+    scoped_refptr<net::GrowableIOBuffer> buffer =
+        base::MakeRefCounted<net::GrowableIOBuffer>();
     buffer->SetCapacity(100);
     strcpy(buffer->data(), data_on_buffer);
     buffer->set_offset(strlen(data_on_buffer));
@@ -120,7 +121,8 @@ class AdbClientSocketTest : public testing::Test {
 
     base::MockCallback<AdbClientSocket::CommandCallback> response_callback;
     EXPECT_CALL(response_callback, Run(error_code, "IO error")).Times(1);
-    scoped_refptr<net::GrowableIOBuffer> buffer = new net::GrowableIOBuffer;
+    scoped_refptr<net::GrowableIOBuffer> buffer =
+        base::MakeRefCounted<net::GrowableIOBuffer>();
     buffer->SetCapacity(100);
     adb_socket.ReadUntilEOF(parse_callback.Get(), response_callback.Get(),
                             buffer, error_code);
@@ -139,7 +141,8 @@ class AdbClientSocketTest : public testing::Test {
     base::MockCallback<AdbClientSocket::CommandCallback> response_callback;
     // The following means "expect not to be called."
     EXPECT_CALL(response_callback, Run(0, "")).Times(0);
-    scoped_refptr<net::GrowableIOBuffer> buffer = new net::GrowableIOBuffer;
+    scoped_refptr<net::GrowableIOBuffer> buffer =
+        base::MakeRefCounted<net::GrowableIOBuffer>();
     int initial_capacity = 4;
     buffer->SetCapacity(initial_capacity);
     int result = adb_socket.socket_->Read(
@@ -165,7 +168,8 @@ class AdbClientSocketTest : public testing::Test {
                 Run(expected_result_code, expected_result_string))
         .Times(1);
 
-    scoped_refptr<net::GrowableIOBuffer> buffer = new net::GrowableIOBuffer;
+    scoped_refptr<net::GrowableIOBuffer> buffer =
+        base::MakeRefCounted<net::GrowableIOBuffer>();
     int initial_capacity = 100;
     buffer->SetCapacity(initial_capacity);
     if (result > 0) {