Convert implicit scoped_refptr constructor calls to explicit ones, part 1

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2010 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 <string>
 #include <vector>
 
 #include "net/base/auth.h"
 #include "net/base/net_log_unittest.h"
 #include "net/http/http_network_session_peer.h"
@@ skipping 328 matching lines @@
   // Read the result of a particular transaction, knowing that we've got
   // multiple transactions in the read pipeline; so as we read, we may have
   // to skip over data destined for other transactions while we consume
   // the data for |trans|.
   int ReadResult(HttpNetworkTransaction* trans,
                  OrderedSocketData* data,
                  std::string* result) {
     const int kSize = 3000;
 
     int bytes_read = 0;
-    scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(kSize);
+    scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(kSize));
     TestCompletionCallback callback;
     while (true) {
       int rv = trans->Read(buf, kSize, &callback);
       if (rv == ERR_IO_PENDING) {
         // Multiple transactions may be in the data set.  Keep pulling off
         // reads until we complete our callback.
         while (!callback.have_result()) {
           data->CompleteRead();
           MessageLoop::current()->RunAllPending();
         }
@@ skipping 95 matching lines @@
 // All tests are run with three different connection types: SPDY after NPN
 // negotiation, SPDY without SSL, and SPDY with SSL.
 INSTANTIATE_TEST_CASE_P(Spdy,
                         SpdyNetworkTransactionTest,
                         ::testing::Values(SPDYNOSSL, SPDYSSL, SPDYNPN));
 
 
 // Verify HttpNetworkTransaction constructor.
 TEST_P(SpdyNetworkTransactionTest, Constructor) {
   SpdySessionDependencies session_deps;
-  scoped_refptr<HttpNetworkSession> session =
-      SpdySessionDependencies::SpdyCreateSession(&session_deps);
+  scoped_refptr<HttpNetworkSession> session(
+      SpdySessionDependencies::SpdyCreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 }
 
 TEST_P(SpdyNetworkTransactionTest, Get) {
   // Construct the request.
   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));
@@ skipping 1225 matching lines @@
             stream->stream()->recv_window_size());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
 
   // Issue a read which will cause a WINDOW_UPDATE to be sent and window
   // size increased to default.
-  scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kUploadDataSize);
+  scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kUploadDataSize));
   rv = trans->Read(buf, kUploadDataSize, NULL);
   EXPECT_EQ(kUploadDataSize, rv);
   std::string content(buf->data(), buf->data()+kUploadDataSize);
   EXPECT_STREQ(kUploadData, content.c_str());
 
   // Schedule the reading of empty data frame with FIN
   data->CompleteRead();
 
   // Force write of WINDOW_UPDATE which was scheduled during the above
   // read.
@@ skipping 345 matching lines @@
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   StartTransactionCallback callback2(helper.session(), helper);
   const int kSize = 3000;
-  scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+  scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   rv = trans->Read(buf, kSize, &callback2);
   // This forces an err_IO_pending, which sets the callback.
   data->CompleteRead();
   // This finishes the read.
   data->CompleteRead();
   helper.VerifyDataConsumed();
 }
 
 class SpdyNetworkTransactionTest::DeleteSessionCallback
     : public CallbackRunner< Tuple1<int> > {
@@ skipping 39 matching lines @@
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   // Setup a user callback which will delete the session, and clear out the
   // memory holding the stream object. Note that the callback deletes trans.
   DeleteSessionCallback callback2(helper);
   const int kSize = 3000;
-  scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+  scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   rv = trans->Read(buf, kSize, &callback2);
   ASSERT_EQ(ERR_IO_PENDING, rv);
   data->CompleteRead();
 
   // Finish running rest of tasks.
   MessageLoop::current()->RunAllPending();
   helper.VerifyDataConsumed();
 }
 
 // Send a spdy request to www.google.com that gets redirected to www.foo.com.
@@ skipping 1262 matching lines @@
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
   std::string content;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 3;
-    scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSmallReadSize);
+    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
     rv = trans->Read(buf, kSmallReadSize, &read_callback);
     if (rv == net::ERR_IO_PENDING) {
       data->CompleteRead();
       rv = read_callback.WaitForResult();
     }
     if (rv > 0) {
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       NOTREACHED();
     }
@@ skipping 145 matching lines @@
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
   std::string content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
-    scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSmallReadSize);
+    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
     rv = trans->Read(buf, kSmallReadSize, &read_callback);
     if (rv == net::ERR_IO_PENDING) {
       data->CompleteRead();
       rv = read_callback.WaitForResult();
     }
     if (rv > 0) {
       EXPECT_EQ(kSmallReadSize, rv);
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       FAIL() << "Unexpected read error: " << rv;
@@ skipping 74 matching lines @@
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
   std::string content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
-    scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSmallReadSize);
+    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
     rv = trans->Read(buf, kSmallReadSize, &read_callback);
     if (rv > 0) {
       EXPECT_EQ(kSmallReadSize, rv);
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       FAIL() << "Unexpected read error: " << rv;
     }
     reads_completed++;
   } while (rv > 0);
 
@@ skipping 68 matching lines @@
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
   std::string content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
-    scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSmallReadSize);
+    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
     rv = trans->Read(buf, kSmallReadSize, &read_callback);
     if (rv == net::ERR_IO_PENDING) {
       data->CompleteRead();
       rv = read_callback.WaitForResult();
     }
     if (rv > 0) {
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       // This test intentionally closes the connection, and will get an error.
       EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
@@ skipping 55 matching lines @@
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
   do {
     const int kReadSize = 256;
-    scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kReadSize);
+    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kReadSize));
     rv = trans->Read(buf, kReadSize, &read_callback);
     if (rv == net::ERR_IO_PENDING) {
       // Complete the read now, which causes buffering to start.
       data->CompleteRead();
       // Destroy the transaction, causing the stream to get cancelled
       // and orphaning the buffered IO task.
       helper.ResetTrans();
       break;
     }
     // We shouldn't get here in this test.
@@ skipping 517 matching lines @@
       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;
   scoped_ptr<SpdySessionDependencies> ssd_proxy(new SpdySessionDependencies());
   // Ensure that this transaction uses the same SpdySessionPool.
-  scoped_refptr<HttpNetworkSession> session_proxy =
-      SpdySessionDependencies::SpdyCreateSession(ssd_proxy.get());
+  scoped_refptr<HttpNetworkSession> session_proxy(
+      SpdySessionDependencies::SpdyCreateSession(ssd_proxy.get()));
   NormalSpdyTransactionHelper helper_proxy(request_proxy,
                                            BoundNetLog(), GetParam());
   HttpNetworkSessionPeer session_peer(session_proxy);
   session_peer.SetProxyService(
           ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
   helper_proxy.session_deps().swap(ssd_proxy);
   helper_proxy.SetSession(session_proxy);
   helper_proxy.RunPreTestSetup();
   helper_proxy.AddData(data_proxy.get());
 
@@ skipping 230 matching lines @@
   // TODO(cbentzel): This is actually the same response object as before, but
   // data has changed.
   const HttpResponseInfo* const response_restart = trans->GetResponseInfo();
   ASSERT_TRUE(response_restart != NULL);
   ASSERT_TRUE(response_restart->headers != NULL);
   EXPECT_EQ(200, response_restart->headers->response_code());
   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
 }
 
 }  // namespace net