diff --git a/net/quic/bidirectional_stream_quic_impl_unittest.cc b/net/quic/bidirectional_stream_quic_impl_unittest.cc
index 2dccbca..b47fb2b8 100644
--- a/net/quic/bidirectional_stream_quic_impl_unittest.cc
+++ b/net/quic/bidirectional_stream_quic_impl_unittest.cc
@@ -412,7 +412,7 @@
         client_headers_include_h2_stream_dependency_(std::get<1>(GetParam())),
         crypto_config_(quic::test::crypto_test_utils::ProofVerifierForTesting(),
                        quic::TlsClientHandshaker::CreateSslCtx()),
-        read_buffer_(new IOBufferWithSize(4096)),
+        read_buffer_(base::MakeRefCounted<IOBufferWithSize>(4096)),
         connection_id_(2),
         stream_id_(GetNthClientInitiatedStreamId(0)),
         client_maker_(version_,
@@ -849,7 +849,8 @@
   request.end_stream_on_headers = true;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->set_trailers_expected(true);
@@ -956,14 +957,16 @@
   request.priority = DEFAULT_PRIORITY;
 
   // Start first request.
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(),
                   session()->CreateHandle(destination_));
 
   // Start second request.
-  scoped_refptr<IOBuffer> read_buffer2(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer2 =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate2(
       new TestDelegateBase(read_buffer2.get(), kReadBufferSize));
   delegate2->Start(&request, net_log().bound(),
@@ -1034,7 +1037,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->DoNotSendRequestHeadersAutomatically();
@@ -1049,8 +1053,10 @@
   // separate packet.
   delegate->SendRequestHeaders();
   // Send a Data packet.
-  scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody1));
-  scoped_refptr<StringIOBuffer> buf2(new StringIOBuffer(kBody2));
+  scoped_refptr<StringIOBuffer> buf1 =
+      base::MakeRefCounted<StringIOBuffer>(kBody1);
+  scoped_refptr<StringIOBuffer> buf2 =
+      base::MakeRefCounted<StringIOBuffer>(kBody2);
 
   std::vector<int> lengths = {buf1->size(), buf2->size()};
   delegate->SendvData({buf1, buf2}, lengths, !kFin);
@@ -1080,9 +1086,12 @@
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
 
   // Send a second Data packet.
-  scoped_refptr<StringIOBuffer> buf3(new StringIOBuffer(kBody3));
-  scoped_refptr<StringIOBuffer> buf4(new StringIOBuffer(kBody4));
-  scoped_refptr<StringIOBuffer> buf5(new StringIOBuffer(kBody5));
+  scoped_refptr<StringIOBuffer> buf3 =
+      base::MakeRefCounted<StringIOBuffer>(kBody3);
+  scoped_refptr<StringIOBuffer> buf4 =
+      base::MakeRefCounted<StringIOBuffer>(kBody4);
+  scoped_refptr<StringIOBuffer> buf5 =
+      base::MakeRefCounted<StringIOBuffer>(kBody5);
 
   delegate->SendvData({buf3, buf4, buf5},
                       {buf3->size(), buf4->size(), buf5->size()}, kFin);
@@ -1143,7 +1152,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->DoNotSendRequestHeadersAutomatically();
@@ -1153,7 +1163,8 @@
   delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Send a Data packet.
-  scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody1));
+  scoped_refptr<StringIOBuffer> buf1 =
+      base::MakeRefCounted<StringIOBuffer>(kBody1);
 
   delegate->SendData(buf1, buf1->size(), false);
   delegate->WaitUntilNextCallback(kOnDataSent);
@@ -1182,7 +1193,8 @@
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
 
   // Send a second Data packet.
-  scoped_refptr<StringIOBuffer> buf2(new StringIOBuffer(kBody2));
+  scoped_refptr<StringIOBuffer> buf2 =
+      base::MakeRefCounted<StringIOBuffer>(kBody2);
 
   delegate->SendData(buf2, buf2->size(), true);
   delegate->WaitUntilNextCallback(kOnDataSent);
@@ -1243,7 +1255,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->DoNotSendRequestHeadersAutomatically();
@@ -1253,8 +1266,10 @@
   delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Send a Data packet.
-  scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody1));
-  scoped_refptr<StringIOBuffer> buf2(new StringIOBuffer(kBody2));
+  scoped_refptr<StringIOBuffer> buf1 =
+      base::MakeRefCounted<StringIOBuffer>(kBody1);
+  scoped_refptr<StringIOBuffer> buf2 =
+      base::MakeRefCounted<StringIOBuffer>(kBody2);
 
   std::vector<int> lengths = {buf1->size(), buf2->size()};
   delegate->SendvData({buf1, buf2}, lengths, !kFin);
@@ -1284,9 +1299,12 @@
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
 
   // Send a second Data packet.
-  scoped_refptr<StringIOBuffer> buf3(new StringIOBuffer(kBody3));
-  scoped_refptr<StringIOBuffer> buf4(new StringIOBuffer(kBody4));
-  scoped_refptr<StringIOBuffer> buf5(new StringIOBuffer(kBody5));
+  scoped_refptr<StringIOBuffer> buf3 =
+      base::MakeRefCounted<StringIOBuffer>(kBody3);
+  scoped_refptr<StringIOBuffer> buf4 =
+      base::MakeRefCounted<StringIOBuffer>(kBody4);
+  scoped_refptr<StringIOBuffer> buf5 =
+      base::MakeRefCounted<StringIOBuffer>(kBody5);
 
   delegate->SendvData({buf3, buf4, buf5},
                       {buf3->size(), buf4->size(), buf5->size()}, kFin);
@@ -1337,7 +1355,8 @@
   request.priority = DEFAULT_PRIORITY;
   request.extra_headers.SetHeader("cookie", std::string(2048, 'A'));
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
       read_buffer.get(), kReadBufferSize, DeleteStreamDelegate::ON_FAILED));
   delegate->DoNotSendRequestHeadersAutomatically();
@@ -1348,7 +1367,8 @@
 
   // Attempt to send the headers and data.
   const char kBody1[] = "here are some data";
-  scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody1));
+  scoped_refptr<StringIOBuffer> buf1 =
+      base::MakeRefCounted<StringIOBuffer>(kBody1);
   delegate->SendData(buf1, buf1->size(), !kFin);
 
   delegate->WaitUntilNextCallback(kOnFailed);
@@ -1371,7 +1391,8 @@
   request.priority = DEFAULT_PRIORITY;
   request.extra_headers.SetHeader("cookie", std::string(2048, 'A'));
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
       read_buffer.get(), kReadBufferSize, DeleteStreamDelegate::ON_FAILED));
   delegate->DoNotSendRequestHeadersAutomatically();
@@ -1383,8 +1404,10 @@
   // Attempt to send the headers and data.
   const char kBody1[] = "here are some data";
   const char kBody2[] = "data keep coming";
-  scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody1));
-  scoped_refptr<StringIOBuffer> buf2(new StringIOBuffer(kBody2));
+  scoped_refptr<StringIOBuffer> buf1 =
+      base::MakeRefCounted<StringIOBuffer>(kBody1);
+  scoped_refptr<StringIOBuffer> buf2 =
+      base::MakeRefCounted<StringIOBuffer>(kBody2);
   std::vector<int> lengths = {buf1->size(), buf2->size()};
   delegate->SendvData({buf1, buf2}, lengths, !kFin);
 
@@ -1411,7 +1434,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(),
@@ -1420,7 +1444,8 @@
   delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Send a DATA frame.
-  scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
+  scoped_refptr<StringIOBuffer> buf =
+      base::MakeRefCounted<StringIOBuffer>(kUploadData);
 
   delegate->SendData(buf, buf->size(), true);
   delegate->WaitUntilNextCallback(kOnDataSent);
@@ -1495,7 +1520,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(),
@@ -1504,7 +1530,8 @@
   delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Send a DATA frame.
-  scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
+  scoped_refptr<StringIOBuffer> buf =
+      base::MakeRefCounted<StringIOBuffer>(kUploadData);
 
   delegate->SendData(buf, buf->size(), true);
   delegate->WaitUntilNextCallback(kOnDataSent);
@@ -1579,7 +1606,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(),
@@ -1601,7 +1629,8 @@
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   // Client sends a data packet.
-  scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
+  scoped_refptr<StringIOBuffer> buf =
+      base::MakeRefCounted<StringIOBuffer>(kUploadData);
 
   delegate->SendData(buf, buf->size(), false);
   delegate->WaitUntilNextCallback(kOnDataSent);
@@ -1666,7 +1695,8 @@
   request.end_stream_on_headers = true;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(),
@@ -1715,7 +1745,8 @@
   request.end_stream_on_headers = true;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(),
@@ -1774,7 +1805,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(),
@@ -1803,7 +1835,8 @@
   delegate->WaitUntilNextCallback(kOnFailed);
 
   // Try to send data after OnFailed(), should not get called back.
-  scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
+  scoped_refptr<StringIOBuffer> buf =
+      base::MakeRefCounted<StringIOBuffer>(kUploadData);
   delegate->SendData(buf, buf->size(), false);
 
   EXPECT_THAT(delegate->ReadData(cb.callback()),
@@ -1832,7 +1865,8 @@
   session()->connection()->CloseConnection(
       quic::QUIC_NO_ERROR, "test", quic::ConnectionCloseBehavior::SILENT_CLOSE);
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(),
@@ -1855,7 +1889,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(),
@@ -1879,7 +1914,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
       read_buffer.get(), kReadBufferSize, DeleteStreamDelegate::ON_FAILED));
   delegate->Start(&request, net_log().bound(),
@@ -1909,7 +1945,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<DeleteStreamDelegate> delegate(
       new DeleteStreamDelegate(read_buffer.get(), kReadBufferSize,
                                DeleteStreamDelegate::ON_STREAM_READY));
@@ -1940,7 +1977,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(),
@@ -1995,7 +2033,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<DeleteStreamDelegate> delegate(
       new DeleteStreamDelegate(read_buffer.get(), kReadBufferSize,
                                DeleteStreamDelegate::ON_HEADERS_RECEIVED));
@@ -2043,7 +2082,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
       read_buffer.get(), kReadBufferSize, DeleteStreamDelegate::ON_DATA_READ));
   delegate->Start(&request, net_log().bound(),
@@ -2102,7 +2142,8 @@
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
 
@@ -2112,7 +2153,8 @@
   delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Send a Data packet with fin set.
-  scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody));
+  scoped_refptr<StringIOBuffer> buf1 =
+      base::MakeRefCounted<StringIOBuffer>(kBody);
   delegate->SendData(buf1, buf1->size(), /*fin*/ true);
   delegate->WaitUntilNextCallback(kOnDataSent);
 
@@ -2167,7 +2209,8 @@
   request.end_stream_on_headers = true;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<DeleteStreamDelegate> delegate(
       new DeleteStreamDelegate(read_buffer.get(), kReadBufferSize,
                                DeleteStreamDelegate::ON_TRAILERS_RECEIVED));
@@ -2235,7 +2278,8 @@
   request.end_stream_on_headers = true;
   request.priority = DEFAULT_PRIORITY;
 
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  scoped_refptr<IOBuffer> read_buffer =
+      base::MakeRefCounted<IOBuffer>(kReadBufferSize);
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->set_trailers_expected(true);
diff --git a/net/quic/quic_chromium_client_stream_test.cc b/net/quic/quic_chromium_client_stream_test.cc
index 8f6ab32..78f7d8b0 100644
--- a/net/quic/quic_chromium_client_stream_test.cc
+++ b/net/quic/quic_chromium_client_stream_test.cc
@@ -209,7 +209,8 @@
   }
 
   void ReadData(quic::QuicStringPiece expected_data) {
-    scoped_refptr<IOBuffer> buffer(new IOBuffer(expected_data.length() + 1));
+    scoped_refptr<IOBuffer> buffer =
+        base::MakeRefCounted<IOBuffer>(expected_data.length() + 1);
     EXPECT_EQ(static_cast<int>(expected_data.length()),
               stream_->Read(buffer.get(), expected_data.length() + 1));
     EXPECT_EQ(expected_data,
@@ -320,7 +321,7 @@
                                      true, callback.callback()));
 
   std::vector<scoped_refptr<IOBuffer>> buffers = {
-      scoped_refptr<IOBuffer>(new IOBuffer(10))};
+      base::MakeRefCounted<IOBuffer>(10)};
   std::vector<int> lengths = {10};
   EXPECT_EQ(
       ERR_CONNECTION_CLOSED,
@@ -372,7 +373,7 @@
 
   // Read the body and verify that it arrives correctly.
   TestCompletionCallback callback;
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(2 * data_len);
   EXPECT_EQ(data_len,
             handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
   EXPECT_EQ(quic::QuicStringPiece(data),
@@ -388,7 +389,7 @@
 
   // Start to read the body.
   TestCompletionCallback callback;
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(2 * data_len);
   EXPECT_EQ(ERR_IO_PENDING,
             handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
 
@@ -426,7 +427,7 @@
 
   // Start to read the body.
   TestCompletionCallback callback;
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(2 * data_len);
   EXPECT_EQ(ERR_IO_PENDING,
             handle_->ReadBody(
                 buffer.get(), 2 * data_len,
@@ -458,7 +459,7 @@
 
   // Read the body and verify that it arrives correctly.
   TestCompletionCallback callback;
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(2 * data_len);
   EXPECT_EQ(data_len,
             handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
   EXPECT_EQ(quic::QuicStringPiece(data),
@@ -499,7 +500,7 @@
 
   // Read the body and verify that it arrives correctly.
   TestCompletionCallback callback;
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(2 * data_len);
   EXPECT_EQ(data_len,
             handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
   EXPECT_EQ(quic::QuicStringPiece(data),
@@ -547,7 +548,7 @@
 
   // Read the body and verify that it arrives correctly.
   TestCompletionCallback callback;
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(2 * data_len);
   EXPECT_EQ(data_len,
             handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
   EXPECT_EQ(quic::QuicStringPiece(data),
@@ -624,9 +625,10 @@
 }
 
 TEST_P(QuicChromiumClientStreamTest, WritevStreamData) {
-  scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer("hello world!"));
-  scoped_refptr<StringIOBuffer> buf2(
-      new StringIOBuffer("Just a small payload"));
+  scoped_refptr<StringIOBuffer> buf1 =
+      base::MakeRefCounted<StringIOBuffer>("hello world!");
+  scoped_refptr<StringIOBuffer> buf2 =
+      base::MakeRefCounted<StringIOBuffer>("Just a small payload");
 
   // All data written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _))
@@ -639,9 +641,10 @@
 }
 
 TEST_P(QuicChromiumClientStreamTest, WritevStreamDataAsync) {
-  scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer("hello world!"));
-  scoped_refptr<StringIOBuffer> buf2(
-      new StringIOBuffer("Just a small payload"));
+  scoped_refptr<StringIOBuffer> buf1 =
+      base::MakeRefCounted<StringIOBuffer>("hello world!");
+  scoped_refptr<StringIOBuffer> buf2 =
+      base::MakeRefCounted<StringIOBuffer>("Just a small payload");
 
   // Only a part of the data is written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _))
@@ -716,7 +719,7 @@
 
   // Now explicitly read the data.
   int data_len = arraysize(data) - 1;
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(data_len + 1));
+  scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(data_len + 1);
   ASSERT_EQ(data_len, stream2->Read(buffer.get(), data_len + 1));
   EXPECT_EQ(quic::QuicStringPiece(data),
             quic::QuicStringPiece(buffer->data(), data_len));
diff --git a/net/quic/quic_chromium_packet_reader.cc b/net/quic/quic_chromium_packet_reader.cc
index a2989106..95478db 100644
--- a/net/quic/quic_chromium_packet_reader.cc
+++ b/net/quic/quic_chromium_packet_reader.cc
@@ -28,8 +28,8 @@
       yield_after_packets_(yield_after_packets),
       yield_after_duration_(yield_after_duration),
       yield_after_(quic::QuicTime::Infinite()),
-      read_buffer_(
-          new IOBufferWithSize(static_cast<size_t>(quic::kMaxPacketSize))),
+      read_buffer_(base::MakeRefCounted<IOBufferWithSize>(
+          static_cast<size_t>(quic::kMaxPacketSize))),
       net_log_(net_log),
       weak_factory_(this) {}
 
diff --git a/net/quic/quic_chromium_packet_writer.cc b/net/quic/quic_chromium_packet_writer.cc
index ff122eb3..80458ac 100644
--- a/net/quic/quic_chromium_packet_writer.cc
+++ b/net/quic/quic_chromium_packet_writer.cc
@@ -87,7 +87,7 @@
     base::SequencedTaskRunner* task_runner)
     : socket_(socket),
       delegate_(nullptr),
-      packet_(new ReusableIOBuffer(quic::kMaxPacketSize)),
+      packet_(base::MakeRefCounted<ReusableIOBuffer>(quic::kMaxPacketSize)),
       write_in_progress_(false),
       force_write_blocked_(false),
       retry_count_(0),
@@ -108,16 +108,16 @@
 
 void QuicChromiumPacketWriter::SetPacket(const char* buffer, size_t buf_len) {
   if (UNLIKELY(!packet_)) {
-    packet_ = new ReusableIOBuffer(
+    packet_ = base::MakeRefCounted<ReusableIOBuffer>(
         std::max(buf_len, static_cast<size_t>(quic::kMaxPacketSize)));
     RecordNotReusableReason(NOT_REUSABLE_NULLPTR);
   }
   if (UNLIKELY(packet_->capacity() < buf_len)) {
-    packet_ = new ReusableIOBuffer(buf_len);
+    packet_ = base::MakeRefCounted<ReusableIOBuffer>(buf_len);
     RecordNotReusableReason(NOT_REUSABLE_TOO_SMALL);
   }
   if (UNLIKELY(!packet_->HasOneRef())) {
-    packet_ = new ReusableIOBuffer(
+    packet_ = base::MakeRefCounted<ReusableIOBuffer>(
         std::max(buf_len, static_cast<size_t>(quic::kMaxPacketSize)));
     RecordNotReusableReason(NOT_REUSABLE_REF_COUNT);
   }
diff --git a/net/quic/quic_http_stream.cc b/net/quic/quic_http_stream.cc
index 6f9105e..5cf110c 100644
--- a/net/quic/quic_http_stream.cc
+++ b/net/quic/quic_http_stream.cc
@@ -238,11 +238,13 @@
     // Set the body buffer size to be the size of the body clamped
     // into the range [10 * quic::kMaxPacketSize, 256 * quic::kMaxPacketSize].
     // With larger bodies, larger buffers reduce CPU usage.
-    raw_request_body_buf_ = new IOBufferWithSize(static_cast<size_t>(std::max(
-        10 * quic::kMaxPacketSize,
-        std::min(request_body_stream_->size(), 256 * quic::kMaxPacketSize))));
+    raw_request_body_buf_ =
+        base::MakeRefCounted<IOBufferWithSize>(static_cast<size_t>(std::max(
+            10 * quic::kMaxPacketSize, std::min(request_body_stream_->size(),
+                                                256 * quic::kMaxPacketSize))));
     // The request body buffer is empty at first.
-    request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), 0);
+    request_body_buf_ =
+        base::MakeRefCounted<DrainableIOBuffer>(raw_request_body_buf_.get(), 0);
   }
 
   // Store the response info.
@@ -618,7 +620,8 @@
     return rv;
   }
 
-  request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), rv);
+  request_body_buf_ =
+      base::MakeRefCounted<DrainableIOBuffer>(raw_request_body_buf_.get(), rv);
   if (rv == 0) {  // Reached the end.
     DCHECK(request_body_stream_->IsEOF());
   }
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index d5f39cc..0356f1b 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -193,7 +193,7 @@
         client_headers_include_h2_stream_dependency_(std::get<1>(GetParam())),
         crypto_config_(quic::test::crypto_test_utils::ProofVerifierForTesting(),
                        quic::TlsClientHandshaker::CreateSslCtx()),
-        read_buffer_(new IOBufferWithSize(4096)),
+        read_buffer_(base::MakeRefCounted<IOBufferWithSize>(4096)),
         promise_id_(GetNthServerInitiatedStreamId(0)),
         stream_id_(GetNthClientInitiatedStreamId(0)),
         connection_id_(2),
diff --git a/net/quic/quic_proxy_client_socket_unittest.cc b/net/quic/quic_proxy_client_socket_unittest.cc
index 81e38feb..9f0ed117 100644
--- a/net/quic/quic_proxy_client_socket_unittest.cc
+++ b/net/quic/quic_proxy_client_socket_unittest.cc
@@ -452,7 +452,8 @@
   }
 
   void AssertWriteReturns(const char* data, int len, int rv) {
-    scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(len));
+    scoped_refptr<IOBufferWithSize> buf =
+        base::MakeRefCounted<IOBufferWithSize>(len);
     memcpy(buf->data(), data, len);
     EXPECT_EQ(rv,
               sock_->Write(buf.get(), buf->size(), write_callback_.callback(),
@@ -460,7 +461,8 @@
   }
 
   void AssertSyncWriteSucceeds(const char* data, int len) {
-    scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(len));
+    scoped_refptr<IOBufferWithSize> buf =
+        base::MakeRefCounted<IOBufferWithSize>(len);
     memcpy(buf->data(), data, len);
     EXPECT_EQ(len,
               sock_->Write(buf.get(), buf->size(), CompletionOnceCallback(),
@@ -468,14 +470,14 @@
   }
 
   void AssertSyncReadEquals(const char* data, int len) {
-    scoped_refptr<IOBuffer> buf(new IOBuffer(len));
+    scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(len);
     ASSERT_EQ(len, sock_->Read(buf.get(), len, CompletionOnceCallback()));
     ASSERT_EQ(spdy::SpdyString(data, len), spdy::SpdyString(buf->data(), len));
     ASSERT_TRUE(sock_->IsConnected());
   }
 
   void AssertAsyncReadEquals(const char* data, int len) {
-    scoped_refptr<IOBuffer> buf(new IOBuffer(len));
+    scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(len);
     ASSERT_EQ(ERR_IO_PENDING,
               sock_->Read(buf.get(), len, read_callback_.callback()));
     EXPECT_TRUE(sock_->IsConnected());
@@ -489,7 +491,7 @@
 
   void AssertReadStarts(const char* data, int len) {
     // Issue the read, which will be completed asynchronously.
-    read_buf_ = new IOBuffer(len);
+    read_buf_ = base::MakeRefCounted<IOBuffer>(len);
     ASSERT_EQ(ERR_IO_PENDING,
               sock_->Read(read_buf_.get(), len, read_callback_.callback()));
     EXPECT_TRUE(sock_->IsConnected());
@@ -1038,7 +1040,7 @@
   AssertSyncReadEquals(kMsg33, kLen33);
 
   // Now attempt to do a read of more data than remains buffered
-  scoped_refptr<IOBuffer> buf(new IOBuffer(kLen33));
+  scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(kLen33);
   ASSERT_EQ(kLen3, sock_->Read(buf.get(), kLen33, CompletionOnceCallback()));
   ASSERT_EQ(spdy::SpdyString(kMsg3, kLen3),
             spdy::SpdyString(buf->data(), kLen3));
@@ -1552,7 +1554,7 @@
   EXPECT_TRUE(sock_->IsConnected());
 
   DeleteSockCallback read_callback(&sock_);
-  scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
+  scoped_refptr<IOBuffer> read_buf = base::MakeRefCounted<IOBuffer>(kLen1);
   ASSERT_EQ(ERR_IO_PENDING,
             sock_->Read(read_buf.get(), kLen1, read_callback.callback()));
 
diff --git a/net/quic/quic_stream_factory_fuzzer.cc b/net/quic/quic_stream_factory_fuzzer.cc
index 0d9ce44e..c3054a4 100644
--- a/net/quic/quic_stream_factory_fuzzer.cc
+++ b/net/quic/quic_stream_factory_fuzzer.cc
@@ -189,7 +189,8 @@
   }
   callback.WaitForResult();
 
-  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kBufferSize);
+  scoped_refptr<net::IOBuffer> buffer =
+      base::MakeRefCounted<net::IOBuffer>(kBufferSize);
   rv = stream->ReadResponseBody(buffer.get(), kBufferSize, callback.callback());
   if (rv == ERR_IO_PENDING)
     callback.WaitForResult();