Fixes to socket_test_util.cc.

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_network_transaction.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 542 matching lines @@
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
@@ skipping 29 matching lines @@
     }
 
     scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
     scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*resp),
       CreateMockRead(*body),
       MockRead(true, 0, 0)  // EOF
     };
 
-    scoped_refptr<DelayedSocketData> data(
+    scoped_ptr<DelayedSocketData> data(
         new DelayedSocketData(1, reads, arraysize(reads),
                               writes, arraysize(writes)));
     HttpRequestInfo http_req = CreateGetRequest();
     http_req.priority = p;
 
     NormalSpdyTransactionHelper helper(http_req, BoundNetLog(), GetParam());
     helper.RunToCompletion(data.get());
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(OK, out.rv);
     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
@@ skipping 39 matching lines @@
     CreateMockRead(*body2),
     CreateMockRead(*resp3, 7),
     CreateMockRead(*body3),
 
     CreateMockRead(*fbody),
     CreateMockRead(*fbody2),
     CreateMockRead(*fbody3),
 
     MockRead(true, 0, 0),  // EOF
   };
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
-  scoped_refptr<OrderedSocketData> data_placeholder(
+  scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   // We require placeholder data because three get requests are sent out, so
   // there needs to be three sets of SSL connection data.
@@ skipping 60 matching lines @@
   };
   MockRead reads[] = {
     CreateMockRead(*resp, 1),
     CreateMockRead(*body),
     CreateMockRead(*resp2, 4),
     CreateMockRead(*body2),
     CreateMockRead(*fbody),
     CreateMockRead(*fbody2),
     MockRead(true, 0, 0),  // EOF
   };
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   MockConnect never_finishing_connect(false, ERR_IO_PENDING);
 
-  scoped_refptr<OrderedSocketData> data_placeholder(
+  scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
   data_placeholder->set_connect_data(never_finishing_connect);
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   // We require placeholder data because two get requests are sent out, so
@@ skipping 60 matching lines @@
   };
   MockRead reads[] = {
     CreateMockRead(*resp, 1),
     CreateMockRead(*body),
     CreateMockRead(*resp2, 4),
     CreateMockRead(*body2),
     CreateMockRead(*fbody),
     CreateMockRead(*fbody2),
     MockRead(true, 0, 0),  // EOF
   };
-  scoped_refptr<OrderedSocketData> preconnect_data(
+  scoped_ptr<OrderedSocketData> preconnect_data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   MockConnect never_finishing_connect(true, ERR_IO_PENDING);
 
-  scoped_refptr<OrderedSocketData> data_placeholder(
+  scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
   data_placeholder->set_connect_data(never_finishing_connect);
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(preconnect_data.get());
   // We require placeholder data because 3 connections are attempted (first is
@@ skipping 100 matching lines @@
     CreateMockRead(*resp2, 7),
     CreateMockRead(*body2),
     CreateMockRead(*fbody2),
     CreateMockRead(*resp3, 12),
     CreateMockRead(*body3),
     CreateMockRead(*fbody3),
 
     MockRead(true, 0, 0),  // EOF
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
-  scoped_refptr<OrderedSocketData> data_placeholder(
+  scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
 
   BoundNetLog log;
   TransactionHelperResult out;
   {
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                        BoundNetLog(), GetParam());
     helper.RunPreTestSetup();
     helper.AddData(data.get());
     // We require placeholder data because three get requests are sent out, so
@@ skipping 116 matching lines @@
     CreateMockRead(*fbody2),
     CreateMockRead(*resp4, 13),
     CreateMockRead(*fbody4),
     CreateMockRead(*resp3, 16),
     CreateMockRead(*body3),
     CreateMockRead(*fbody3),
 
     MockRead(true, 0, 0),  // EOF
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
         writes, arraysize(writes)));
-  scoped_refptr<OrderedSocketData> data_placeholder(
+  scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
       BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   // We require placeholder data because four get requests are sent out, so
   // there needs to be four sets of SSL connection data.
@@ skipping 113 matching lines @@
     CreateMockRead(*settings_frame, 1),
     CreateMockRead(*resp),
     CreateMockRead(*body),
     CreateMockRead(*fbody),
     CreateMockRead(*resp2, 7),
     CreateMockRead(*body2),
     CreateMockRead(*fbody2),
     MockRead(true, 0, 0),  // EOF
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
         writes, arraysize(writes)));
-  scoped_refptr<OrderedSocketData> data_placeholder(
+  scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
       BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   // We require placeholder data because three get requests are sent out, so
   // there needs to be three sets of SSL connection data.
@@ skipping 106 matching lines @@
   };
   MockRead reads[] = {
     CreateMockRead(*settings_frame, 1),
     CreateMockRead(*resp),
     CreateMockRead(*body),
     CreateMockRead(*fin_body),
     CreateMockRead(*resp2, 7),
     MockRead(true, ERR_CONNECTION_RESET, 0),  // Abort!
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
         writes, arraysize(writes)));
-  scoped_refptr<OrderedSocketData> data_placeholder(
+  scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
       BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   // We require placeholder data because three get requests are sent out, so
   // there needs to be three sets of SSL connection data.
@@ skipping 98 matching lines @@
     "content-length", "1234"
   };
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPacket(kSynReplyHeader,
       NULL, 0, kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
 }
@@ skipping 50 matching lines @@
     "content-length", "1234"
   };
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPacket(kSynReplyHeader,
       NULL, 0, kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
 }
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionTest, Post) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyPost(kUploadDataSize, NULL, 0));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*body),  // POST upload frame
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(2, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreatePostRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
@@ skipping 11 matching lines @@
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*chunk1),
     CreateMockRead(*chunk2),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(2, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateChunkedPostRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 }
@@ skipping 17 matching lines @@
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
@@ skipping 23 matching lines @@
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
@@ skipping 16 matching lines @@
       request.upload_data, NULL));
   ASSERT_EQ(request.upload_data->GetContentLength(), stream->size());
   scoped_ptr<spdy::SpdyFrame> stream_reply(ConstructSpdyPostSynReply(NULL, 0));
   scoped_ptr<spdy::SpdyFrame> stream_body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream_reply, 2),
     CreateMockRead(*stream_body, 3),
     MockRead(false, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(0, reads, arraysize(reads), NULL, 0));
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
 
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SYN_REPLY_NOT_RECEIVED, out.rv);
@@ skipping 43 matching lines @@
 }
 
 // Test that the transaction doesn't crash when we don't have a reply.
 TEST_P(SpdyNetworkTransactionTest, ResponseWithoutSynReply) {
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads), NULL, 0));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SYN_REPLY_NOT_RECEIVED, out.rv);
 }
 
 // Test that the transaction doesn't crash when we get two replies on the same
 // stream ID. See http://crbug.com/45639.
 TEST_P(SpdyNetworkTransactionTest, ResponseWithTwoSynReplies) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
@@ skipping 67 matching lines @@
     CreateMockRead(*window_update_dummy),
     CreateMockRead(*window_update),     // Four updates, therefore window
     CreateMockRead(*window_update),     // size should increase by
     CreateMockRead(*window_update),     // kDeltaWindowSize * 4
     CreateMockRead(*window_update),
     CreateMockRead(*resp),
     CreateMockRead(*body_end),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(0, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(kDefaultURL);
   request.upload_data = new UploadData();
   for (int i = 0; i < kFrameCount; ++i)
     request.upload_data->AppendBytes(content->c_str(), content->size());
@@ skipping 44 matching lines @@
       ConstructSpdyBodyFrame(1, NULL, 0, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body_no_fin),
     MockRead(true, ERR_IO_PENDING, 0),  // Force a pause
     CreateMockRead(*body_fin),
     MockRead(true, ERR_IO_PENDING, 0),  // Force a pause
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.AddData(data.get());
   helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
@@ skipping 76 matching lines @@
   MockRead reads[] = {
     CreateMockRead(*window_update2),
     CreateMockRead(*window_update2),
     CreateMockRead(*window_update),
     CreateMockRead(*window_update),
     CreateMockRead(*window_update),
     MockRead(true, ERR_IO_PENDING, 0),  // Wait for the RST to be written.
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(0, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data = new UploadData();
   for (int i = 0; i < kFrameCount; ++i)
     request.upload_data->AppendBytes(content->c_str(), content->size());
@@ skipping 87 matching lines @@
     CreateMockRead(*window_update),
     CreateMockRead(*window_update),
     CreateMockRead(*reply),
     CreateMockRead(*body2),
     CreateMockRead(*body3),
     MockRead(true, 0, 0)  // EOF
   };
 
   // Force all writes to happen before any read, last write will not
   // actually queue a frame, due to window size being 0.
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(nwrites, reads, arraysize(reads),
                             writes.get(), nwrites));
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data = new UploadData();
   scoped_ptr<std::string> upload_data(
       new std::string(spdy::kSpdyStreamInitialWindowSize, 'a'));
   upload_data->append(kUploadData, kUploadDataSize);
@@ skipping 129 matching lines @@
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame2),
              arraysize(kGetBodyFrame2), 4),
     MockRead(true, ERR_IO_PENDING, 5),  // Force a pause
     MockRead(true, 0, 0, 6),  // EOF
   };
   MockRead reads2[] = {
     CreateMockRead(*resp, 2),
     MockRead(true, 0, 0, 3),  // EOF
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
-  scoped_refptr<DelayedSocketData> data2(
+  scoped_ptr<DelayedSocketData> data2(
       new DelayedSocketData(1, reads2, arraysize(reads2),
                             writes2, arraysize(writes2)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   helper.AddData(data2.get());
   HttpNetworkTransaction* trans = helper.trans();
 
@@ skipping 25 matching lines @@
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp.get(), 2),
     MockRead(true, ERR_IO_PENDING, 3),  // Force a pause
     CreateMockRead(*body.get(), 4),
     MockRead(true, 0, 0, 5),  // EOF
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
@@ skipping 75 matching lines @@
   scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body2(ConstructSpdyBodyFrame(1, true));
   MockWrite writes2[] = {
     CreateMockWrite(*req2, 1),
   };
   MockRead reads2[] = {
     CreateMockRead(*resp2, 2),
     CreateMockRead(*body2, 3),
     MockRead(true, 0, 0, 4)  // EOF
   };
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
-  scoped_refptr<OrderedSocketData> data2(
+  scoped_ptr<OrderedSocketData> data2(
       new OrderedSocketData(reads2, arraysize(reads2),
                             writes2, arraysize(writes2)));
 
   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
   HttpStreamFactory::set_force_spdy_over_ssl(false);
   HttpStreamFactory::set_force_spdy_always(true);
   TestDelegate d;
   {
     net::URLRequest r(GURL("http://www.google.com/"), &d);
     SpdyURLRequestContext* spdy_url_request_context =
@@ skipping 102 matching lines @@
   scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body2(ConstructSpdyBodyFrame(1, true));
   MockWrite writes2[] = {
     CreateMockWrite(*req2, 1),
   };
   MockRead reads2[] = {
     CreateMockRead(*resp2, 2),
     CreateMockRead(*body2, 3),
     MockRead(true, 0, 0, 5)  // EOF
   };
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
-  scoped_refptr<OrderedSocketData> data2(
+  scoped_ptr<OrderedSocketData> data2(
       new OrderedSocketData(reads2, arraysize(reads2),
                             writes2, arraysize(writes2)));
 
   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
   HttpStreamFactory::set_force_spdy_over_ssl(false);
   HttpStreamFactory::set_force_spdy_always(true);
   TestDelegate d;
   TestDelegate d2;
   scoped_refptr<SpdyURLRequestContext> spdy_url_request_context(
       new SpdyURLRequestContext());
@@ skipping 63 matching lines @@
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream1_body, 4, false),
     MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 5),
     MockRead(true, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
-  scoped_refptr<OrderedSocketData> data(new OrderedSocketData(
+  scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
   RunServerPushTest(data.get(),
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
@@ skipping 32 matching lines @@
     CreateMockRead(*stream2_syn, 3),
     MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 5),
     CreateMockRead(*stream1_body, 4, false),
     MockRead(true, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
-  scoped_refptr<OrderedSocketData> data(new OrderedSocketData(
+  scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
   RunServerPushTest(data.get(),
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
@@ skipping 25 matching lines @@
   scoped_ptr<spdy::SpdyFrame>
     stream2_rst(ConstructSpdyRstStream(2, spdy::PROTOCOL_ERROR));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream2_rst, 4),
     CreateMockRead(*stream1_body, 5, false),
     MockRead(true, ERR_IO_PENDING, 6),  // Force a pause
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
@@ skipping 61 matching lines @@
     CreateMockRead(*stream3_syn, 4),
     CreateMockRead(*stream1_body, 6, false),
     MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 7),
     MockRead(true, ERR_IO_PENDING, 8),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
-  scoped_refptr<OrderedSocketData> data(new OrderedSocketData(
+  scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
   RunServerPushTest(data.get(),
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
@@ skipping 42 matching lines @@
              arraysize(kPushBodyFrame3) - 1, 6),
     MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame4),
              arraysize(kPushBodyFrame4) - 1, 7),
     CreateMockRead(*stream1_body, 8, false),
     MockRead(true, ERR_IO_PENDING, 9),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed my darling hello my baby");
-  scoped_refptr<OrderedSocketData> data(new OrderedSocketData(
+  scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
   RunServerPushTest(data.get(),
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
@@ skipping 43 matching lines @@
              arraysize(kPushBodyFrame3) - 1, 7),
     MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame4),
              arraysize(kPushBodyFrame4) - 1, 8),
     CreateMockRead(*stream1_body.get(), 9, false),
     MockRead(true, ERR_IO_PENDING, 10)  // Force a pause.
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed my darling hello my baby");
-  scoped_refptr<OrderedSocketData> data(new OrderedSocketData(
+  scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
   RunServerPushTest(data.get(),
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
@@ skipping 25 matching lines @@
                                     2,
                                     0,
                                     "http://www.google.com/foo.dat"));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream1_body, 4),
     MockRead(true, ERR_IO_PENDING, 5)  // Force a pause
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
@@ skipping 41 matching lines @@
                                     2,
                                     9,
                                     "http://www.google.com/foo.dat"));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream1_body, 4),
     MockRead(true, ERR_IO_PENDING, 5),  // Force a pause
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
@@ skipping 37 matching lines @@
       stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame>
       stream2_syn(ConstructSpdyPush(NULL, 0, 2, 1));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream1_body, 4),
     MockRead(true, ERR_IO_PENDING, 5)  // Force a pause
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
@@ skipping 68 matching lines @@
         ConstructSpdyGetSynReply(test_cases[i].extra_headers,
                                  test_cases[i].num_headers,
                                  1));
     scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*resp),
       CreateMockRead(*body),
       MockRead(true, 0, 0)  // EOF
     };
 
-    scoped_refptr<DelayedSocketData> data(
+    scoped_ptr<DelayedSocketData> data(
         new DelayedSocketData(1, reads, arraysize(reads),
                               writes, arraysize(writes)));
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                        BoundNetLog(), GetParam());
     helper.RunToCompletion(data.get());
     TransactionHelperResult out = helper.output();
 
     EXPECT_EQ(OK, out.rv);
     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
     EXPECT_EQ("hello!", out.response_data);
@@ skipping 128 matching lines @@
     // Attach the headers to the request.
     int header_count = test_cases[i].num_headers[0];
 
     HttpRequestInfo request = CreateGetRequest();
     for (int ct = 0; ct < header_count; ct++) {
       const char* header_key = test_cases[i].extra_headers[0][ct * 2];
       const char* header_value = test_cases[i].extra_headers[0][ct * 2 + 1];
       request.extra_headers.SetHeader(header_key, header_value);
     }
 
-    scoped_refptr<DelayedSocketData> data(
+    scoped_ptr<DelayedSocketData> data(
         new DelayedSocketData(1, reads, arraysize(reads),
                               writes, arraysize(writes)));
     NormalSpdyTransactionHelper helper(request,
                                        BoundNetLog(), GetParam());
     helper.RunToCompletion(data.get());
     TransactionHelperResult out = helper.output();
 
     EXPECT_EQ(OK, out.rv) << i;
     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line) << i;
     EXPECT_EQ("hello!", out.response_data) << i;
@@ skipping 85 matching lines @@
                             NULL, 0,
                             test_cases[i].headers,
                             test_cases[i].num_headers));
     scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*resp),
       CreateMockRead(*body),
       MockRead(true, 0, 0)  // EOF
     };
 
-    scoped_refptr<DelayedSocketData> data(
+    scoped_ptr<DelayedSocketData> data(
         new DelayedSocketData(1, reads, arraysize(reads),
                               writes, arraysize(writes)));
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                        BoundNetLog(), GetParam());
     helper.RunToCompletion(data.get());
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(ERR_INCOMPLETE_SPDY_HEADERS, out.rv);
   }
 }
 
@@ skipping 18 matching lines @@
       MockWrite(true, 0, 0)  // EOF
     };
 
     scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*test_cases[i].syn_reply),
       CreateMockRead(*body),
       MockRead(true, 0, 0)  // EOF
     };
 
-    scoped_refptr<DelayedSocketData> data(
+    scoped_ptr<DelayedSocketData> data(
         new DelayedSocketData(1, reads, arraysize(reads),
                               writes, arraysize(writes)));
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                        BoundNetLog(), GetParam());
     helper.RunToCompletion(data.get());
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
   }
 }
 
 // Test that we shutdown correctly on write errors.
 TEST_P(SpdyNetworkTransactionTest, WriteError) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = {
     // We'll write 10 bytes successfully
     MockWrite(true, req->data(), 10),
     // Followed by ERROR!
     MockWrite(true, ERR_FAILED),
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(2, NULL, 0,
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_FAILED, out.rv);
   data->Reset();
 }
 
 // Test that partial writes work.
 TEST_P(SpdyNetworkTransactionTest, PartialWrite) {
   // Chop the SYN_STREAM frame into 5 chunks.
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   const int kChunks = 5;
   scoped_array<MockWrite> writes(ChopWriteFrame(*req.get(), kChunks));
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(kChunks, reads, arraysize(reads),
                             writes.get(), kChunks));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
@@ skipping 11 matching lines @@
   MockWrite writes[] = {
     CreateMockWrite(*compressed),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
   data->Reset();
 
   EnableCompression(false);
@@ skipping 11 matching lines @@
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
   net::CapturingBoundNetLog log(net::CapturingNetLog::kUnbounded);
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequestWithUserAgent(),
                                      log.bound(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
@@ skipping 81 matching lines @@
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
     MockRead(true, ERR_IO_PENDING),  // Force a pause
     MockRead(true, combined_data_frames, combined_data_frames_len),
     MockRead(true, ERR_IO_PENDING),  // Force a pause
     CreateMockRead(*last_frame),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
 
   TestCompletionCallback callback;
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 72 matching lines @@
                     combined_data_frames, arraysize(combined_data_frames));
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
     MockRead(true, ERR_IO_PENDING),  // Force a pause
     MockRead(true, combined_data_frames, combined_data_frames_len),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
@@ skipping 75 matching lines @@
   char combined_frames[200];
   int combined_frames_len =
       CombineFrames(frames, arraysize(frames),
                     combined_frames, arraysize(combined_frames));
 
   MockRead reads[] = {
     MockRead(true, combined_frames, combined_frames_len),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
@@ skipping 68 matching lines @@
       CombineFrames(data_frames, arraysize(data_frames),
                     combined_data_frames, arraysize(combined_data_frames));
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
     MockRead(true, ERR_IO_PENDING),  // Force a wait
     MockRead(true, combined_data_frames, combined_data_frames_len),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
@@ skipping 60 matching lines @@
       framer.CreateDataFrame(1, "message", 7, spdy::DATA_FLAG_NONE));
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
     MockRead(true, ERR_IO_PENDING),  // Force a wait
     CreateMockRead(*data_frame),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
   TestCompletionCallback callback;
 
@@ skipping 108 matching lines @@
   }
 
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*reply),
     CreateMockRead(*body),
     CreateMockRead(*settings_frame),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   helper.AddData(data.get());
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
@@ skipping 97 matching lines @@
                         NULL,
                         0));
 
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*reply),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(2, reads, arraysize(reads),
                             writes, arraysize(writes)));
   helper.AddData(data.get());
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
@@ skipping 23 matching lines @@
 TEST_P(SpdyNetworkTransactionTest, GoAwayWithActiveStream) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> go_away(ConstructSpdyGoAway());
   MockRead reads[] = {
     CreateMockRead(*go_away),
     MockRead(true, 0, 0),  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
-  helper.AddData(data);
+  helper.AddData(data.get());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_ABORTED, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest, CloseWithActiveStream) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
     MockRead(false, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   BoundNetLog log;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      log, GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
@@ skipping 61 matching lines @@
   MockWrite writes_SPDYNOSSL[] = {
     CreateMockWrite(*req, 0),
   };
 
   MockRead reads_SPDYNOSSL[] = {
     CreateMockRead(*resp, 1),
     CreateMockRead(*body.get(), 2),
     MockRead(true, 0, 0, 3),
   };
 
-  scoped_refptr<OrderedSocketData> data;
+  scoped_ptr<OrderedSocketData> data;
   switch(GetParam()) {
     case SPDYNOSSL:
-      data = new OrderedSocketData(reads_SPDYNOSSL,
-                                   arraysize(reads_SPDYNOSSL),
-                                   writes_SPDYNOSSL,
-                                   arraysize(writes_SPDYNOSSL));
+      data.reset(new OrderedSocketData(reads_SPDYNOSSL,
+                                       arraysize(reads_SPDYNOSSL),
+                                       writes_SPDYNOSSL,
+                                       arraysize(writes_SPDYNOSSL)));
       break;
     case SPDYSSL:
-      data = new OrderedSocketData(reads_SPDYSSL, arraysize(reads_SPDYSSL),
-                                   writes_SPDYSSL, arraysize(writes_SPDYSSL));
+      data.reset(new OrderedSocketData(reads_SPDYSSL,
+                                       arraysize(reads_SPDYSSL),
+                                       writes_SPDYSSL,
+                                       arraysize(writes_SPDYSSL)));
       break;
     case SPDYNPN:
-      data = new OrderedSocketData(reads_SPDYNPN, arraysize(reads_SPDYNPN),
-                                   writes_SPDYNPN, arraysize(writes_SPDYNPN));
+      data.reset(new OrderedSocketData(reads_SPDYNPN,
+                                       arraysize(reads_SPDYNPN),
+                                       writes_SPDYNPN,
+                                       arraysize(writes_SPDYNPN)));
       break;
     default:
       NOTREACHED();
   }
 
   helper.AddData(data.get());
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
@@ skipping 41 matching lines @@
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp, 2),
     CreateMockRead(*body, 3),
     MockRead(true, ERR_IO_PENDING, 4),  // Force a pause
     MockRead(true, 0, 5)  // EOF
   };
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   TransactionHelperResult out;
   out.rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
 
@@ skipping 57 matching lines @@
     MockWrite(false, kConnect80, arraysize(kConnect80) - 1, 0),
     CreateMockWrite(*req2, 2),
   };
   MockRead reads_SPDYSSL[] = {
     MockRead(false, kHTTP200, arraysize(kHTTP200) - 1, 1),
     CreateMockRead(*resp2, 3),
     CreateMockRead(*body2, 4),
     MockRead(true, 0, 0, 5),
   };
 
-  scoped_refptr<OrderedSocketData> data_proxy;
+  scoped_ptr<OrderedSocketData> data_proxy;
   switch(GetParam()) {
     case SPDYNPN:
-      data_proxy = new OrderedSocketData(reads_SPDYNPN,
-                                         arraysize(reads_SPDYNPN),
-                                         writes_SPDYNPN,
-                                         arraysize(writes_SPDYNPN));
+      data_proxy.reset(new OrderedSocketData(reads_SPDYNPN,
+                                             arraysize(reads_SPDYNPN),
+                                             writes_SPDYNPN,
+                                             arraysize(writes_SPDYNPN)));
       break;
     case SPDYNOSSL:
-      data_proxy = new OrderedSocketData(reads_SPDYNOSSL,
-                                         arraysize(reads_SPDYNOSSL),
-                                         writes_SPDYNOSSL,
-                                         arraysize(writes_SPDYNOSSL));
+      data_proxy.reset(new OrderedSocketData(reads_SPDYNOSSL,
+                                             arraysize(reads_SPDYNOSSL),
+                                             writes_SPDYNOSSL,
+                                             arraysize(writes_SPDYNOSSL)));
       break;
     case SPDYSSL:
-      data_proxy = new OrderedSocketData(reads_SPDYSSL,
-                                         arraysize(reads_SPDYSSL),
-                                         writes_SPDYSSL,
-                                         arraysize(writes_SPDYSSL));
+      data_proxy.reset(new OrderedSocketData(reads_SPDYSSL,
+                                             arraysize(reads_SPDYSSL),
+                                             writes_SPDYSSL,
+                                             arraysize(writes_SPDYSSL)));
       break;
     default:
       NOTREACHED();
   }
 
   // Create another request to www.google.com, but this time through a proxy.
   HttpRequestInfo request_proxy;
   request_proxy.method = "GET";
   request_proxy.url = GURL("http://www.google.com/foo.dat");
   request_proxy.load_flags = 0;
@@ skipping 57 matching lines @@
     // Induce the RST while waiting for our transaction to send.
     VARIANT_RST_DURING_SEND_COMPLETION,
     // Induce the RST while waiting for our transaction to read.
     // In this case, the send completed - everything copied into the SNDBUF.
     VARIANT_RST_DURING_READ_COMPLETION
   };
 
   for (int variant = VARIANT_RST_DURING_SEND_COMPLETION;
        variant <= VARIANT_RST_DURING_READ_COMPLETION;
        ++variant) {
-    scoped_refptr<DelayedSocketData> data1(
+    scoped_ptr<DelayedSocketData> data1(
         new DelayedSocketData(1, reads, arraysize(reads),
                               NULL, 0));
 
-    scoped_refptr<DelayedSocketData> data2(
+    scoped_ptr<DelayedSocketData> data2(
         new DelayedSocketData(1, reads2, arraysize(reads2),
                                NULL, 0));
 
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                        BoundNetLog(), GetParam());
     helper.AddData(data1.get());
     helper.AddData(data2.get());
     helper.RunPreTestSetup();
 
     for (int i = 0; i < 2; ++i) {
@@ skipping 42 matching lines @@
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1,
                             spdy_reads, arraysize(spdy_reads),
                             spdy_writes, arraysize(spdy_writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   net::HttpStreamFactory::set_spdy_enabled(false);
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello from http"),
     MockRead(false, OK),
   };
-  scoped_refptr<DelayedSocketData> data2(
+  scoped_ptr<DelayedSocketData> data2(
       new DelayedSocketData(1, http_reads, arraysize(http_reads),
                             NULL, 0));
   NormalSpdyTransactionHelper helper2(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper2.SetSpdyDisabled();
   helper2.RunToCompletion(data2.get());
   TransactionHelperResult out2 = helper2.output();
   EXPECT_EQ(OK, out2.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out2.status_line);
   EXPECT_EQ("hello from http", out2.response_data);
@@ skipping 41 matching lines @@
   scoped_ptr<spdy::SpdyFrame> resp_data(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> body_data(ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp_authentication, 2),
     CreateMockRead(*body_authentication, 3),
     CreateMockRead(*resp_data, 5),
     CreateMockRead(*body_data, 6),
     MockRead(true, 0, 7),
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(spdy_reads, arraysize(spdy_reads),
                             spdy_writes, arraysize(spdy_writes)));
   HttpRequestInfo request(CreateGetRequest());
   BoundNetLog net_log;
   NormalSpdyTransactionHelper helper(request, net_log, GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
   TestCompletionCallback callback;
@@ skipping 88 matching lines @@
     CreateMockRead(*stream2_headers, 4),
     CreateMockRead(*stream1_body, 5, false),
     MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 6),
     MockRead(true, ERR_IO_PENDING, 7),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
-  scoped_refptr<OrderedSocketData> data(new OrderedSocketData(
+  scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
   RunServerPushTest(data.get(),
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
@@ skipping 338 matching lines @@
                                                 0,
                                                 0));
   scoped_ptr<spdy::SpdyFrame> stream1_body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply),
     CreateMockRead(*stream1_headers),
     CreateMockRead(*stream1_body),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
@@ skipping 37 matching lines @@
   scoped_ptr<spdy::SpdyFrame> stream1_body(ConstructSpdyBodyFrame(1, false));
   scoped_ptr<spdy::SpdyFrame> stream1_body2(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply),
     CreateMockRead(*stream1_body),
     CreateMockRead(*stream1_headers),
     CreateMockRead(*stream1_body2),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 }
@@ skipping 37 matching lines @@
   scoped_ptr<spdy::SpdyFrame> stream1_body(ConstructSpdyBodyFrame(1, false));
   scoped_ptr<spdy::SpdyFrame> stream1_body2(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply),
     CreateMockRead(*stream1_body),
     CreateMockRead(*stream1_headers),
     CreateMockRead(*stream1_body2),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushCrossOriginCorrectness) {
@@ skipping 57 matching lines @@
     MockRead reads[] = {
       CreateMockRead(*stream1_reply, 2),
       CreateMockRead(*stream2_syn, 3),
       CreateMockRead(*stream1_body, 5, false),
       MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
                arraysize(kPushBodyFrame), 6),
       MockRead(true, ERR_IO_PENDING, 7),  // Force a pause
     };
 
     HttpResponseInfo response;
-    scoped_refptr<OrderedSocketData> data(new OrderedSocketData(
+    scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
         reads,
         arraysize(reads),
         writes,
         arraysize(writes)));
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL(url_to_fetch);
     request.load_flags = 0;
     NormalSpdyTransactionHelper helper(request,
                                        BoundNetLog(), GetParam());
     helper.RunPreTestSetup();
-    helper.AddData(data);
+    helper.AddData(data.get());
 
     HttpNetworkTransaction* trans = helper.trans();
 
     // Start the transaction with basic parameters.
     TestCompletionCallback callback;
 
     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     rv = callback.WaitForResult();
 
     // Read the response body.
     std::string result;
-    ReadResult(trans, data, &result);
+    ReadResult(trans, data.get(), &result);
 
     // Verify that we consumed all test data.
     EXPECT_TRUE(data->at_read_eof());
     EXPECT_TRUE(data->at_write_eof());
 
     // Verify the SYN_REPLY.
     // Copy the response info, because trans goes away.
     response = *trans->GetResponseInfo();
 
     VerifyStreamsClosed(helper);
@@ skipping 17 matching lines @@
       ConstructSpdyRstStream(1, spdy::REFUSED_STREAM));
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(3, true));
   MockRead reads[] = {
     CreateMockRead(*refused, 2),
     CreateMockRead(*resp, 4),
     CreateMockRead(*body, 5),
     MockRead(true, 0, 6)  // EOF
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
@@ skipping 15 matching lines @@
                                     << " Write index: "
                                     << data->write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 }  // namespace net