Prepare for separating owning and non-owning net:IOBuffers.

Use IOBufferWithSize for the owning cases. Currently this is
the same as IOBuffer, but eventually IOBuffer will evolve to be
a non-owning class.

This cl applies the changes to /chrome.

This CL was uploaded by git cl split.

R=asully@chromium.org, dgozman@chromium.org, harringtond@chromium.org, pawliczek@chromium.org, petermarshall@chromium.org, rdevlin.cronin@chromium.org, sadym@chromium.org

Bug: 1493389
Change-Id: I741217693e48b58ab6ff8ee95acf0215ab7ec920
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4996470
Reviewed-by: Devlin Cronin <rdevlin.cronin@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Reviewed-by: Piotr Pawliczek <pawliczek@chromium.org>
Reviewed-by: Mathias Bynens <mathias@chromium.org>
Reviewed-by: Peter Marshall <petermarshall@chromium.org>
Commit-Queue: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Dan H <harringtond@chromium.org>
Reviewed-by: Austin Sullivan <asully@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1221071}

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

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

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

@@ -23,8 +23,8 @@ BufferingFileStreamReader::BufferingFileStreamReader(
       preloading_buffer_length_(preloading_buffer_length),
       max_bytes_to_read_(max_bytes_to_read),
       bytes_read_(0),
-      preloading_buffer_(
-          base::MakeRefCounted<net::IOBuffer>(preloading_buffer_length)),
+      preloading_buffer_(base::MakeRefCounted<net::IOBufferWithSize>(
+          preloading_buffer_length)),
       preloading_buffer_offset_(0),
       preloaded_bytes_(0) {}
 

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

@@ -105,8 +105,7 @@ 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 =
-        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
+    auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(buffer.get(), kChunkSize,
                                    base::BindOnce(&LogValue<int>, &read_log));
@@ -123,8 +122,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
   // the internal file stream reader.
   {
     inner_read_log.clear();
-    scoped_refptr<net::IOBuffer> buffer =
-        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
+    auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(buffer.get(), kChunkSize,
                                    base::BindOnce(&LogValue<int>, &read_log));
@@ -140,8 +138,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
   // valid to return less bytes than requested.
   {
     inner_read_log.clear();
-    scoped_refptr<net::IOBuffer> buffer =
-        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
+    auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(buffer.get(), kChunkSize,
                                    base::BindOnce(&LogValue<int>, &read_log));
@@ -157,8 +154,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
   // file stream reader.
   {
     inner_read_log.clear();
-    scoped_refptr<net::IOBuffer> buffer =
-        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
+    auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(buffer.get(), kChunkSize,
                                    base::BindOnce(&LogValue<int>, &read_log));
@@ -181,8 +177,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) {
 
   // First read couple of bytes, so the internal buffer is filled out.
   {
-    scoped_refptr<net::IOBuffer> buffer =
-        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
+    auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(buffer.get(), kChunkSize,
                                    base::BindOnce(&LogValue<int>, &read_log));
@@ -202,8 +197,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) {
   // as much as available in the internal buffer.
   {
     inner_read_log.clear();
-    scoped_refptr<net::IOBuffer> buffer =
-        base::MakeRefCounted<net::IOBuffer>(read_bytes);
+    auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(read_bytes);
     std::vector<int> read_log;
     const int result = reader.Read(buffer.get(), read_bytes,
                                    base::BindOnce(&LogValue<int>, &read_log));
@@ -219,8 +213,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) {
   // the internal buffer.
   {
     inner_read_log.clear();
-    scoped_refptr<net::IOBuffer> buffer =
-        base::MakeRefCounted<net::IOBuffer>(read_bytes);
+    auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(read_bytes);
     std::vector<int> read_log;
     const int result = reader.Read(buffer.get(), read_bytes,
                                    base::BindOnce(&LogValue<int>, &read_log));
@@ -243,8 +236,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
       kPreloadingBufferLength, kFileSize);
   // First read couple of bytes, so the internal buffer is filled out.
   {
-    scoped_refptr<net::IOBuffer> buffer =
-        base::MakeRefCounted<net::IOBuffer>(kChunkSize);
+    auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(kChunkSize);
     std::vector<int> read_log;
     const int result = reader.Read(buffer.get(), kChunkSize,
                                    base::BindOnce(&LogValue<int>, &read_log));
@@ -263,8 +255,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
     inner_read_log.clear();
     const int chunk_size = 20;
     ASSERT_LT(kPreloadingBufferLength, chunk_size);
-    scoped_refptr<net::IOBuffer> buffer =
-        base::MakeRefCounted<net::IOBuffer>(chunk_size);
+    auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(chunk_size);
     std::vector<int> read_log;
     const int result = reader.Read(buffer.get(), chunk_size,
                                    base::BindOnce(&LogValue<int>, &read_log));
@@ -292,8 +283,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
   ASSERT_LT(read_bytes, kPreloadingBufferLength);
   ASSERT_LE(read_bytes, total_bytes_to_read);
 
-  scoped_refptr<net::IOBuffer> buffer =
-      base::MakeRefCounted<net::IOBuffer>(read_bytes);
+  auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(read_bytes);
   std::vector<int> read_log;
   const int result = reader.Read(buffer.get(), read_bytes,
                                  base::BindOnce(&LogValue<int>, &read_log));
@@ -319,8 +309,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
   const int read_bytes = 2;
   ASSERT_LT(read_bytes, kPreloadingBufferLength);
 
-  scoped_refptr<net::IOBuffer> buffer =
-      base::MakeRefCounted<net::IOBuffer>(read_bytes);
+  auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(read_bytes);
   std::vector<int> read_log;
   const int result = reader.Read(buffer.get(), read_bytes,
                                  base::BindOnce(&LogValue<int>, &read_log));
@@ -340,8 +329,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_WithError) {
           new FakeFileStreamReader(&inner_read_log, net::ERR_ACCESS_DENIED)),
       kPreloadingBufferLength, kFileSize);
 
-  scoped_refptr<net::IOBuffer> buffer =
-      base::MakeRefCounted<net::IOBuffer>(kChunkSize);
+  auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(kChunkSize);
   std::vector<int> read_log;
   const int result = reader.Read(buffer.get(), kChunkSize,
                                  base::BindOnce(&LogValue<int>, &read_log));

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

@@ -19,8 +19,8 @@ BufferingFileStreamWriter::BufferingFileStreamWriter(
     int intermediate_buffer_length)
     : file_stream_writer_(std::move(file_stream_writer)),
       intermediate_buffer_length_(intermediate_buffer_length),
-      intermediate_buffer_(
-          base::MakeRefCounted<net::IOBuffer>(intermediate_buffer_length_)),
+      intermediate_buffer_(base::MakeRefCounted<net::IOBufferWithSize>(
+          intermediate_buffer_length_)),
       buffered_bytes_(0) {}
 
 BufferingFileStreamWriter::~BufferingFileStreamWriter() {

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

@@ -139,7 +139,7 @@ TEST_F(FileSystemProviderFileStreamReader, Read_AllAtOnce) {
   const int64_t initial_offset = 0;
   FileStreamReader reader(nullptr, file_url_, initial_offset,
                           *fake_file_->metadata->modification_time);
-  scoped_refptr<net::IOBuffer> io_buffer = base::MakeRefCounted<net::IOBuffer>(
+  auto io_buffer = base::MakeRefCounted<net::IOBufferWithSize>(
       base::checked_cast<size_t>(*fake_file_->metadata->size));
 
   const int result =
@@ -162,7 +162,7 @@ TEST_F(FileSystemProviderFileStreamReader, Read_WrongFile) {
   const int64_t initial_offset = 0;
   FileStreamReader reader(nullptr, wrong_file_url_, initial_offset,
                           *fake_file_->metadata->modification_time);
-  scoped_refptr<net::IOBuffer> io_buffer = base::MakeRefCounted<net::IOBuffer>(
+  auto io_buffer = base::MakeRefCounted<net::IOBufferWithSize>(
       base::checked_cast<size_t>(*fake_file_->metadata->size));
 
   const int result =
@@ -183,8 +183,7 @@ 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 =
-        base::MakeRefCounted<net::IOBuffer>(1);
+    auto io_buffer = base::MakeRefCounted<net::IOBufferWithSize>(1);
     const int result =
         reader.Read(io_buffer.get(), 1,
                     base::BindOnce(&EventLogger::OnRead, logger.GetWeakPtr()));
@@ -207,8 +206,7 @@ TEST_F(FileSystemProviderFileStreamReader, Read_Slice) {
 
   FileStreamReader reader(nullptr, file_url_, initial_offset,
                           *fake_file_->metadata->modification_time);
-  scoped_refptr<net::IOBuffer> io_buffer =
-      base::MakeRefCounted<net::IOBuffer>(length);
+  auto io_buffer = base::MakeRefCounted<net::IOBufferWithSize>(length);
 
   const int result =
       reader.Read(io_buffer.get(), length,
@@ -234,8 +232,7 @@ TEST_F(FileSystemProviderFileStreamReader, Read_Beyond) {
 
   FileStreamReader reader(nullptr, file_url_, initial_offset,
                           *fake_file_->metadata->modification_time);
-  scoped_refptr<net::IOBuffer> io_buffer =
-      base::MakeRefCounted<net::IOBuffer>(length);
+  auto io_buffer = base::MakeRefCounted<net::IOBufferWithSize>(length);
 
   const int result =
       reader.Read(io_buffer.get(), length,
@@ -258,7 +255,7 @@ TEST_F(FileSystemProviderFileStreamReader, Read_ModifiedFile) {
   FileStreamReader reader(nullptr, file_url_, initial_offset,
                           base::Time::Max());
 
-  scoped_refptr<net::IOBuffer> io_buffer = base::MakeRefCounted<net::IOBuffer>(
+  auto io_buffer = base::MakeRefCounted<net::IOBufferWithSize>(
       base::checked_cast<size_t>(*fake_file_->metadata->size));
   const int result =
       reader.Read(io_buffer.get(), *fake_file_->metadata->size,
@@ -277,7 +274,7 @@ TEST_F(FileSystemProviderFileStreamReader, Read_ExpectedModificationTimeNull) {
   const int64_t initial_offset = 0;
   FileStreamReader reader(nullptr, file_url_, initial_offset, base::Time());
 
-  scoped_refptr<net::IOBuffer> io_buffer = base::MakeRefCounted<net::IOBuffer>(
+  auto io_buffer = base::MakeRefCounted<net::IOBufferWithSize>(
       base::checked_cast<size_t>(*fake_file_->metadata->size));
   const int result =
       reader.Read(io_buffer.get(), *fake_file_->metadata->size,

chrome/browser/ash/file_system_provider/operations/read_file_unittest.cc

@@ -89,7 +89,7 @@ class FileSystemProviderOperationsReadFileTest : public testing::Test {
         kExtensionId, MountOptions(kFileSystemId, "" /* display_name */),
         base::FilePath(), false /* configurable */, true /* watchable */,
         extensions::SOURCE_FILE, IconSet());
-    io_buffer_ = base::MakeRefCounted<net::IOBuffer>(kOffset + kLength);
+    io_buffer_ = base::MakeRefCounted<net::IOBufferWithSize>(kOffset + kLength);
   }
 
   ProvidedFileSystemInfo file_system_info_;

chrome/browser/ash/fileapi/fallback_copy_in_foreign_file.cc

@@ -157,7 +157,7 @@ Copier::Copier(storage::AsyncFileUtil& async_file_util,
       dest_url_(dest_url),
       temp_url_(CreateTempURL(dest_url)),
       temp_url_needs_deleting_(false),
-      io_buffer_(base::MakeRefCounted<net::IOBuffer>(kBufferSize)),
+      io_buffer_(base::MakeRefCounted<net::IOBufferWithSize>(kBufferSize)),
       fs_writer_(nullptr),
       file_(base::File::FILE_ERROR_FAILED) {}
 

chrome/browser/ash/fusebox/fusebox_copy_to_fd.cc

@@ -66,7 +66,7 @@ FDCopier::FDCopier(scoped_refptr<storage::FileSystemContext> fs_context,
                                                     0,
                                                     INT64_MAX,
                                                     base::Time())),
-      buffer_(base::MakeRefCounted<net::IOBuffer>(kBufferLen)),
+      buffer_(base::MakeRefCounted<net::IOBufferWithSize>(kBufferLen)),
       scoped_fd_(std::move(scoped_fd)),
       callback_(std::move(callback)) {}
 

chrome/browser/ash/fusebox/fusebox_read_writer.cc

@@ -296,7 +296,7 @@ void ReadWriter::Read(scoped_refptr<storage::FileSystemContext> fs_context,
 
   constexpr int64_t min_length = 256;
   constexpr int64_t max_length = 262144;  // 256 KiB.
-  scoped_refptr<net::IOBuffer> buffer = base::MakeRefCounted<net::IOBuffer>(
+  auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(
       std::max(min_length, std::min(max_length, length)));
 
   // Save the pointer before we std::move fs_reader into a base::OnceCallback.

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

@@ -245,8 +245,8 @@ void AdbClientSocket::ReadResponse(CommandCallback callback,
     std::move(callback).Run(result, "IO error");
     return;
   }
-  scoped_refptr<net::IOBuffer> response_buffer =
-      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
+  auto response_buffer =
+      base::MakeRefCounted<net::IOBufferWithSize>(kBufferSize);
   auto split_callback = base::SplitOnceCallback(
       base::BindOnce(&AdbClientSocket::OnResponseHeader, base::Unretained(this),
                      std::move(callback), is_void, response_buffer));

chrome/browser/devtools/device/android_device_manager.cc

@@ -197,8 +197,8 @@ class HttpRequest {
     pieces.insert(pieces.end(), {crlf});
 
     std::string request = base::StrCat(pieces);
-    scoped_refptr<net::IOBuffer> base_buffer =
-        base::MakeRefCounted<net::IOBuffer>(request.size());
+    auto base_buffer =
+        base::MakeRefCounted<net::IOBufferWithSize>(request.size());
     memcpy(base_buffer->data(), request.data(), request.size());
     request_ = base::MakeRefCounted<net::DrainableIOBuffer>(
         std::move(base_buffer), request.size());
@@ -210,7 +210,7 @@ class HttpRequest {
     if (!CheckNetResultOrDie(result))
       return;
 
-    response_buffer_ = base::MakeRefCounted<net::IOBuffer>(kBufferSize);
+    response_buffer_ = base::MakeRefCounted<net::IOBufferWithSize>(kBufferSize);
 
     result = socket_->Read(
         response_buffer_.get(), kBufferSize,

chrome/browser/devtools/device/android_web_socket.cc

@@ -74,9 +74,7 @@ class AndroidDeviceManager::AndroidWebSocket::WebSocketImpl {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(socket_);
 
-    scoped_refptr<net::IOBuffer> buffer =
-        base::MakeRefCounted<net::IOBuffer>(kBufferSize);
-
+    auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(kBufferSize);
     if (!response_buffer_.empty())
       ProcessResponseBuffer(buffer);
     else

chrome/browser/devtools/device/port_forwarding_controller.cc

@@ -296,8 +296,7 @@ class SocketTunnel {
   void Pump(net::StreamSocket* from, net::StreamSocket* to) {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
-    scoped_refptr<net::IOBuffer> buffer =
-        base::MakeRefCounted<net::IOBuffer>(kBufferSize);
+    auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(kBufferSize);
     int result =
         from->Read(buffer.get(), kBufferSize,
                    base::BindOnce(&SocketTunnel::OnRead, base::Unretained(this),

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

@@ -62,8 +62,7 @@ void OpenedForCommand(UsbDeviceProvider::CommandCallback callback,
     std::move(callback).Run(result, std::string());
     return;
   }
-  scoped_refptr<net::IOBuffer> buffer =
-      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
+  auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(kBufferSize);
   auto split_callback = base::SplitOnceCallback(base::BindOnce(
       &OnRead, socket, buffer, std::string(), std::move(callback)));
   result =

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

@@ -248,7 +248,7 @@ void NativeMessageProcessHost::DoRead() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   while (!closed_ && !read_pending_) {
-    read_buffer_ = base::MakeRefCounted<net::IOBuffer>(kReadBufferSize);
+    read_buffer_ = base::MakeRefCounted<net::IOBufferWithSize>(kReadBufferSize);
     int result =
         read_stream_->Read(read_buffer_.get(), kReadBufferSize,
                            base::BindOnce(&NativeMessageProcessHost::OnRead,

chrome/browser/media_galleries/fileapi/mtp_file_stream_reader.cc

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

chrome/browser/media_galleries/fileapi/readahead_file_stream_reader.cc

@@ -102,7 +102,7 @@ void ReadaheadFileStreamReader::ReadFromSourceIfNeeded() {
   source_has_pending_read_ = true;
 
   scoped_refptr<net::IOBuffer> buf =
-      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
+      base::MakeRefCounted<net::IOBufferWithSize>(kBufferSize);
   int result = source_->Read(
       buf.get(), kBufferSize,
       base::BindOnce(&ReadaheadFileStreamReader::OnFinishReadFromSource,

chrome/browser/offline_pages/offline_page_request_handler.cc

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

chrome/browser/offline_pages/offline_page_url_loader.cc

@@ -294,7 +294,7 @@ void OfflinePageURLLoader::OnReceiveResponse(
       base::BindRepeating(&OfflinePageURLLoader::OnHandleReady,
                           weak_ptr_factory_.GetWeakPtr()));
 
-  buffer_ = base::MakeRefCounted<net::IOBuffer>(kBufferSize);
+  buffer_ = base::MakeRefCounted<net::IOBufferWithSize>(kBufferSize);
   ReadRawData();
 }
 

chrome/services/cups_proxy/socket_manager.cc

@@ -159,7 +159,8 @@ void ThreadSafeHelper::ProxyToCups(std::vector<uint8_t> request,
 
   // Fill io_buffer with request to write.
   in_flight_->io_buffer = base::MakeRefCounted<net::DrainableIOBuffer>(
-      base::MakeRefCounted<net::IOBuffer>(request.size()), request.size());
+      base::MakeRefCounted<net::IOBufferWithSize>(request.size()),
+      request.size());
   base::ranges::copy(request, in_flight_->io_buffer->data());
 
   ConnectIfNeeded();
@@ -220,7 +221,7 @@ void ThreadSafeHelper::OnWrite(int result) {
   // Prime io_buffer for reading.
   in_flight_->response = std::make_unique<std::vector<uint8_t>>();
   in_flight_->io_buffer = base::MakeRefCounted<net::DrainableIOBuffer>(
-      base::MakeRefCounted<net::IOBuffer>(kHttpMaxBufferSize),
+      base::MakeRefCounted<net::IOBufferWithSize>(kHttpMaxBufferSize),
       kHttpMaxBufferSize);
 
   // Start reading response from CUPS.

chrome/test/chromedriver/net/adb_client_socket.cc

@@ -170,8 +170,8 @@ class HttpOverAdbSocket {
     if (!CheckNetResultOrDie(result))
       return;
 
-    scoped_refptr<net::IOBuffer> response_buffer =
-        base::MakeRefCounted<net::IOBuffer>(kBufferSize);
+    auto response_buffer =
+        base::MakeRefCounted<net::IOBufferWithSize>(kBufferSize);
 
     result = socket_->Read(
         response_buffer.get(), kBufferSize,