Convert implicit scoped_refptr constructor calls to explicit ones, part 1

net/http/http_cache_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 "net/http/http_cache.h"
 
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/scoped_vector.h"
 #include "base/string_util.h"
@@ skipping 555 matching lines @@
     return (rv == net::OK) ? static_cast<MockDiskCache*>(backend) : NULL;
   }
 
   // Helper function for reading response info from the disk cache.
   static bool ReadResponseInfo(disk_cache::Entry* disk_entry,
                                net::HttpResponseInfo* response_info,
                                bool* response_truncated) {
     int size = disk_entry->GetDataSize(0);
 
     TestCompletionCallback cb;
-    scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(size);
+    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(size));
     int rv = disk_entry->ReadData(0, 0, buffer, size, &cb);
     rv = cb.GetResult(rv);
     EXPECT_EQ(size, rv);
 
     return net::HttpCache::ParseResponseInfo(buffer->data(), size,
                                              response_info,
                                              response_truncated);
   }
 
   // Helper function for writing response info into the disk cache.
   static bool WriteResponseInfo(disk_cache::Entry* disk_entry,
                                 const net::HttpResponseInfo* response_info,
                                 bool skip_transient_headers,
                                 bool response_truncated) {
     Pickle pickle;
     response_info->Persist(
         &pickle, skip_transient_headers, response_truncated);
 
     TestCompletionCallback cb;
-    scoped_refptr<net::WrappedIOBuffer> data = new net::WrappedIOBuffer(
-        reinterpret_cast<const char*>(pickle.data()));
+    scoped_refptr<net::WrappedIOBuffer> data(new net::WrappedIOBuffer(
+        reinterpret_cast<const char*>(pickle.data())));
     int len = static_cast<int>(pickle.size());
 
     int rv =  disk_entry->WriteData(0, 0, data, len, &cb, true);
     rv = cb.GetResult(rv);
     return (rv == len);
   }
 
   // Helper function to synchronously open a backend entry.
   bool OpenBackendEntry(const std::string& key, disk_cache::Entry** entry) {
     TestCompletionCallback cb;
@@ skipping 336 matching lines @@
   TEST_MODE_NORMAL,
   &RangeTransactionServer::RangeHandler,
   0
 };
 
 // Verifies the response headers (|response|) match a partial content
 // response for the range starting at |start| and ending at |end|.
 void Verify206Response(std::string response, int start, int end) {
   std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
                                                             response.size()));
-  scoped_refptr<net::HttpResponseHeaders> headers =
-      new net::HttpResponseHeaders(raw_headers);
+  scoped_refptr<net::HttpResponseHeaders> headers(
+      new net::HttpResponseHeaders(raw_headers));
 
   ASSERT_EQ(206, headers->response_code());
 
   int64 range_start, range_end, object_size;
   ASSERT_TRUE(
       headers->GetContentRange(&range_start, &range_end, &object_size));
   int64 content_length = headers->GetContentLength();
 
   int length = end - start + 1;
   ASSERT_EQ(length, content_length);
@@ skipping 881 matching lines @@
   TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans;
   int rv = cache.http_cache()->CreateTransaction(&trans);
   EXPECT_EQ(net::OK, rv);
   rv = trans->Start(&request, &callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::OK, rv);
 
-  scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(256);
+  scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
   rv = trans->Read(buf, 256, &callback);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Test that destroying the transaction while it is reading from the cache
   // works properly.
   trans.reset();
 
   // Make sure we pump any pending events, which should include a call to
   // HttpCache::Transaction::OnCacheReadCompleted.
   MessageLoop::current()->RunAllPending();
@@ skipping 1669 matching lines @@
 
   rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that the entry has some data stored.
-  scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(10);
+  scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
 
   // Destroy the transaction.
   delete c;
 
   // Verify that the entry has not been deleted.
   disk_cache::Entry* entry;
@@ skipping 20 matching lines @@
   rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that we revalidate the entry and read from the cache (a single
   // read will return while waiting for the network).
-  scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(5);
+  scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(5));
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   EXPECT_EQ(5, c->callback.GetResult(rv));
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Destroy the transaction before completing the read.
   delete c;
 
   // We have the read and the delete (OnProcessPendingQueue) waiting on the
   // message loop. This means that a new transaction will just reuse the same
@@ skipping 25 matching lines @@
   rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
   rv = c->callback.WaitForResult();
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that we revalidate the entry and read from the cache (a single
   // read will return while waiting for the network).
-  scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(5);
+  scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(5));
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   EXPECT_EQ(5, c->callback.GetResult(rv));
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Destroy the transaction before completing the read.
   delete c;
 
   // We have the read and the delete (OnProcessPendingQueue) waiting on the
   // message loop. This means that a new transaction will just reuse the same
@@ skipping 377 matching lines @@
 
   rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that the entry has some data stored.
-  scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(10);
+  scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
 
   // Destroy the transaction.
   delete c;
 
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
@@ skipping 23 matching lines @@
 
   rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that the entry has some data stored.
-  scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(10);
+  scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
 
   // Destroy the transaction.
   delete c;
 
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
@@ skipping 23 matching lines @@
 
   rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that the entry has some data stored.
-  scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(10);
+  scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
 
   // We want to cancel the request when the transaction is busy.
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
   EXPECT_FALSE(c->callback.have_result());
 
@@ skipping 712 matching lines @@
   // Now return 200 when validating the entry so the metadata will be lost.
   MockTransaction trans2(kTypicalGET_Transaction);
   trans2.load_flags = net::LOAD_VALIDATE_CACHE;
   RunTransactionTestWithResponseInfo(cache.http_cache(), trans2, &response);
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(4, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }