DeterministicSocketDataProvider should not be RefCounted

net/spdy/spdy_network_transaction_spdy2_unittest.cc

 // Copyright (c) 2012 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"
 #include "base/bind_helpers.h"
+#include "base/memory/scoped_vector.h"
 #include "net/base/auth.h"
 #include "net/base/net_log_unittest.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/spdy/buffered_spdy_framer.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
@@ skipping 200 matching lines @@
     void RunToCompletion(StaticSocketDataProvider* data) {
       RunPreTestSetup();
       AddData(data);
       RunDefaultTest();
       VerifyDataConsumed();
     }
 
     void AddData(StaticSocketDataProvider* data) {
       DCHECK(!deterministic_);
       data_vector_.push_back(data);
-      linked_ptr<SSLSocketDataProvider> ssl_(
-          new SSLSocketDataProvider(ASYNC, OK));
-      if (test_type_ == SPDYNPN) {
-        ssl_->SetNextProto(kProtoSPDY2);
-      }
-      ssl_vector_.push_back(ssl_);
+      SSLSocketDataProvider* ssl_provider =
+          new SSLSocketDataProvider(ASYNC, OK);
+      if (test_type_ == SPDYNPN)
+        ssl_provider->SetNextProto(kProtoSPDY2);
+
+      ssl_vector_.push_back(ssl_provider);
       if (test_type_ == SPDYNPN || test_type_ == SPDYSSL)
-        session_deps_->socket_factory->AddSSLSocketDataProvider(ssl_.get());
+        session_deps_->socket_factory->AddSSLSocketDataProvider(ssl_provider);
+
       session_deps_->socket_factory->AddSocketDataProvider(data);
       if (test_type_ == SPDYNPN) {
         MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
-        linked_ptr<StaticSocketDataProvider>
-            hanging_non_alternate_protocol_socket(
-                new StaticSocketDataProvider(NULL, 0, NULL, 0));
+        StaticSocketDataProvider* hanging_non_alternate_protocol_socket =
+            new StaticSocketDataProvider(NULL, 0, NULL, 0);
         hanging_non_alternate_protocol_socket->set_connect_data(
             never_finishing_connect);
         session_deps_->socket_factory->AddSocketDataProvider(
-            hanging_non_alternate_protocol_socket.get());
+            hanging_non_alternate_protocol_socket);
         alternate_vector_.push_back(hanging_non_alternate_protocol_socket);
       }
     }
 
     void AddDeterministicData(DeterministicSocketData* data) {
       DCHECK(deterministic_);
       data_vector_.push_back(data);
-      linked_ptr<SSLSocketDataProvider> ssl_(
-          new SSLSocketDataProvider(ASYNC, OK));
-      if (test_type_ == SPDYNPN) {
-        ssl_->SetNextProto(kProtoSPDY2);
-      }
-      ssl_vector_.push_back(ssl_);
+      SSLSocketDataProvider* ssl_provider =
+          new SSLSocketDataProvider(ASYNC, OK);
+      if (test_type_ == SPDYNPN)
+        ssl_provider->SetNextProto(kProtoSPDY2);
+
+      ssl_vector_.push_back(ssl_provider);
       if (test_type_ == SPDYNPN || test_type_ == SPDYSSL) {
         session_deps_->deterministic_socket_factory->
-            AddSSLSocketDataProvider(ssl_.get());
+            AddSSLSocketDataProvider(ssl_provider);
       }
       session_deps_->deterministic_socket_factory->AddSocketDataProvider(data);
       if (test_type_ == SPDYNPN) {
         MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
-        scoped_refptr<DeterministicSocketData>
-            hanging_non_alternate_protocol_socket(
-            new DeterministicSocketData(NULL, 0, NULL, 0));
+        DeterministicSocketData* hanging_non_alternate_protocol_socket =
+            new DeterministicSocketData(NULL, 0, NULL, 0);
         hanging_non_alternate_protocol_socket->set_connect_data(
             never_finishing_connect);
         session_deps_->deterministic_socket_factory->AddSocketDataProvider(
             hanging_non_alternate_protocol_socket);
         alternate_deterministic_vector_.push_back(
             hanging_non_alternate_protocol_socket);
       }
     }
 
     // This can only be called after RunPreTestSetup. It adds a Data Provider,
@@ skipping 20 matching lines @@
     scoped_ptr<SpdySessionDependencies>& session_deps() {
       return session_deps_;
     }
     int port() const { return port_; }
     SpdyNetworkTransactionSpdy2TestTypes test_type() const {
       return test_type_;
     }
 
    private:
     typedef std::vector<StaticSocketDataProvider*> DataVector;
-    typedef std::vector<linked_ptr<SSLSocketDataProvider> > SSLVector;
-    typedef std::vector<linked_ptr<StaticSocketDataProvider> > AlternateVector;
-    typedef std::vector<scoped_refptr<DeterministicSocketData> >
-        AlternateDeterministicVector;
+    typedef ScopedVector<SSLSocketDataProvider> SSLVector;
+    typedef ScopedVector<StaticSocketDataProvider> AlternateVector;
+    typedef ScopedVector<DeterministicSocketData> AlternateDeterministicVector;
     HttpRequestInfo request_;
     scoped_ptr<SpdySessionDependencies> session_deps_;
     scoped_refptr<HttpNetworkSession> session_;
     TransactionHelperResult output_;
     scoped_ptr<StaticSocketDataProvider> first_transaction_;
     SSLVector ssl_vector_;
     TestCompletionCallback callback;
     scoped_ptr<HttpNetworkTransaction> trans_;
     scoped_ptr<HttpNetworkTransaction> trans_http_;
     DataVector data_vector_;
@@ skipping 1439 matching lines @@
     MockWrite(SYNCHRONOUS, 0, 0, 2),
     CreateMockWrite(*rst.get(), 3, SYNCHRONOUS),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp.get(), 1, ASYNC),
     MockRead(ASYNC, 0, 0, 4)  // EOF
   };
 
-  scoped_refptr<DeterministicSocketData> data(
+  DeterministicSocketData* data =
       new DeterministicSocketData(reads, arraysize(reads),
-                                  writes, arraysize(writes)));
+                                  writes, arraysize(writes));
+
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam(), NULL);
   helper.SetDeterministic();
   helper.RunPreTestSetup();
-  helper.AddDeterministicData(data.get());
+  helper.AddDeterministicData(data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   data->SetStop(2);
   data->Run();
   helper.ResetTrans();
@@ skipping 180 matching lines @@
     CreateMockWrite(*req, 0, SYNCHRONOUS),
     CreateMockWrite(*rst, 2, SYNCHRONOUS),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 0, 3)  // EOF
   };
 
-  scoped_refptr<DeterministicSocketData> data(
+  DeterministicSocketData* data =
       new DeterministicSocketData(reads, arraysize(reads),
-                            writes, arraysize(writes)));
+                            writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(),
                                      GetParam(), NULL);
   helper.SetDeterministic();
   helper.RunPreTestSetup();
-  helper.AddDeterministicData(data.get());
+  helper.AddDeterministicData(data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   data->SetStop(2);
   data->Run();
@@ skipping 2975 matching lines @@
     CreateMockRead(*stream1_body, 3),
     CreateMockRead(*stream2_headers, 4),
     MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 5),
     MockRead(ASYNC, 0, 5),  // EOF
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
-  scoped_refptr<DeterministicSocketData> data(new DeterministicSocketData(
-      reads,
-      arraysize(reads),
-      writes,
-      arraysize(writes)));
+  DeterministicSocketData* data =
+      new DeterministicSocketData(reads, arraysize(reads),
+                                  writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam(), NULL);
   helper.SetDeterministic();
-  helper.AddDeterministicData(static_cast<DeterministicSocketData*>(data));
+  helper.AddDeterministicData(data);
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM,
   // and the body of the primary stream, but before we've received the HEADERS
   // for the pushed stream.
   data->SetStop(3);
 
   // Start the transaction.
@@ skipping 10 matching lines @@
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(helper.session()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   data->RunFor(3);
   MessageLoop::current()->RunAllPending();
 
   // Read the server push body.
   std::string result2;
-  ReadResult(trans2.get(), data.get(), &result2);
+  ReadResult(trans2.get(), data, &result2);
   // Read the response body.
   std::string result;
   ReadResult(trans, data, &result);
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data->at_read_eof());
   EXPECT_TRUE(data->at_write_eof());
 
   // Verify that the received push data is same as the expected push data.
   EXPECT_EQ(result2.compare(expected_push_result), 0)
@@ skipping 90 matching lines @@
     CreateMockRead(*stream2_headers1, 4),
     CreateMockRead(*stream2_headers2, 5),
     MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 6),
     MockRead(ASYNC, 0, 6),  // EOF
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
-  scoped_refptr<DeterministicSocketData> data(new DeterministicSocketData(
-      reads,
-      arraysize(reads),
-      writes,
-      arraysize(writes)));
+  DeterministicSocketData* data =
+      new DeterministicSocketData(reads, arraysize(reads),
+                                  writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam(), NULL);
   helper.SetDeterministic();
-  helper.AddDeterministicData(static_cast<DeterministicSocketData*>(data));
+  helper.AddDeterministicData(data);
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM,
   // the first HEADERS frame, and the body of the primary stream, but before
   // we've received the final HEADERS for the pushed stream.
   data->SetStop(4);
 
   // Start the transaction.
@@ skipping 424 matching lines @@
   MockRead reads[] = {
     CreateMockRead(*resp1, 1),
     CreateMockRead(*body1, 2),
     CreateMockRead(*resp2, 5),
     CreateMockRead(*body2, 6),
     CreateMockRead(*resp3, 7),
     CreateMockRead(*body3, 8),
     MockRead(ASYNC, 0, 9)  // EOF
   };
 
-  scoped_refptr<DeterministicSocketData> data(
+  DeterministicSocketData* data =
       new DeterministicSocketData(reads, arraysize(reads),
-                                  writes, arraysize(writes)));
+                                  writes, arraysize(writes));
+
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam(), NULL);
   helper.SetDeterministic();
   helper.RunPreTestSetup();
-  helper.AddDeterministicData(data.get());
+  helper.AddDeterministicData(data);
 
   // Start the first transaction to set up the SpdySession
   HttpNetworkTransaction* trans = helper.trans();
   TestCompletionCallback callback;
   HttpRequestInfo info1 = CreateGetRequest();
   info1.priority = LOWEST;
   int rv = trans->Start(&info1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Run the message loop, but do not allow the write to complete.
@@ skipping 29 matching lines @@
   // And now we can allow everything else to run to completion.
   data->SetStop(10);
   data->Run();
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(OK, callback3.WaitForResult());
 
   helper.VerifyDataConsumed();
 }
 
 }  // namespace net