Convert implicit scoped_refptr constructor calls to explicit ones, part 1

webkit/appcache/appcache_update_job_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/stl_util-inl.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 #include "net/base/net_errors.h"
@@ skipping 979 matching lines @@
     expect_newest_cache_ = cache;  // newest cache unaffected by update
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, NO_UPDATE_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, NO_UPDATE_EVENT);
 
     // Seed storage with expected manifest data.
     const std::string seed_data(kManifest1Contents);
-    scoped_refptr<net::StringIOBuffer> io_buffer =
-        new net::StringIOBuffer(seed_data);
+    scoped_refptr<net::StringIOBuffer> io_buffer(
+        new net::StringIOBuffer(seed_data));
     write_callback_.reset(
         new net::CompletionCallbackImpl<AppCacheUpdateJobTest>(this,
             &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
     response_writer_->WriteData(io_buffer, seed_data.length(),
                                 write_callback_.get());
 
     // Start update after data write completes asynchronously.
   }
 
   void StartUpdateAfterSeedingStorageData(int result) {
@@ skipping 81 matching lines @@
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);  // final
     frontend2->AddExpectedEvent(ids2, UPDATE_READY_EVENT);
 
     // Seed storage with expected manifest data different from manifest1.
     const std::string seed_data("different");
-    scoped_refptr<net::StringIOBuffer> io_buffer =
-        new net::StringIOBuffer(seed_data);
+    scoped_refptr<net::StringIOBuffer> io_buffer(
+        new net::StringIOBuffer(seed_data));
     write_callback_.reset(
         new net::CompletionCallbackImpl<AppCacheUpdateJobTest>(this,
             &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
     response_writer_->WriteData(io_buffer, seed_data.length(),
                                 write_callback_.get());
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeLoadFromNewestCacheTest() {
@@ skipping 40 matching lines @@
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "Cache-Control: max-age=8675309\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->request_time = base::Time::Now();
     response_info->response_time = base::Time::Now();
     response_info->headers = headers;  // adds ref to headers
-    scoped_refptr<HttpResponseInfoIOBuffer> io_buffer =
-        new HttpResponseInfoIOBuffer(response_info);  // adds ref to info
+    scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
+        new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     write_callback_.reset(
         new net::CompletionCallbackImpl<AppCacheUpdateJobTest>(this,
             &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
     response_writer_->WriteInfo(io_buffer, write_callback_.get());
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeNoLoadFromNewestCacheTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
@@ skipping 36 matching lines @@
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "Expires: Thu, 01 Dec 1994 16:00:00 GMT\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->request_time = base::Time::Now();
     response_info->response_time = base::Time::Now();
     response_info->headers = headers;  // adds ref to headers
-    scoped_refptr<HttpResponseInfoIOBuffer> io_buffer =
-        new HttpResponseInfoIOBuffer(response_info);  // adds ref to info
+    scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
+        new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     write_callback_.reset(
         new net::CompletionCallbackImpl<AppCacheUpdateJobTest>(this,
             &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
     response_writer_->WriteInfo(io_buffer, write_callback_.get());
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeLoadFromNewestCacheVaryHeaderTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
@@ skipping 36 matching lines @@
         "HTTP/1.1 200 OK\0"
         "Cache-Control: max-age=8675309\0"
         "Vary: blah\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->request_time = base::Time::Now();
     response_info->response_time = base::Time::Now();
     response_info->headers = headers;  // adds ref to headers
-    scoped_refptr<HttpResponseInfoIOBuffer> io_buffer =
-        new HttpResponseInfoIOBuffer(response_info);  // adds ref to info
+    scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
+        new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     write_callback_.reset(
         new net::CompletionCallbackImpl<AppCacheUpdateJobTest>(this,
             &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
     response_writer_->WriteInfo(io_buffer, write_callback_.get());
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeSuccessMergedTypesTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
@@ skipping 529 matching lines @@
         "HTTP/1.1 200 OK\0"
         "Content-type: text/cache-manifest\0"
         "Last-Modified: Sat, 29 Oct 1994 19:43:31 GMT\0"
         "\0";
     const std::string kRawHeaders(kData, arraysize(kData));
     MakeAppCacheResponseInfo(kManifestUrl, kManifestResponseId, kRawHeaders);
 
     group_ = new AppCacheGroup(
         service_.get(), kManifestUrl,
         service_->storage()->NewGroupId());
-    scoped_refptr<AppCache> cache =
+    scoped_refptr<AppCache> cache(
         MakeCacheForGroup(service_->storage()->NewCacheId(),
-                          kManifestResponseId);
+                          kManifestResponseId));
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     host->SelectCache(MockHttpServer::GetMockUrl("files/empty1"),
                       kNoCacheId, kManifestUrl);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     tested_manifest_ = EMPTY_MANIFEST;
     tested_manifest_path_override_ = "files/notmodified";
@@ skipping 834 matching lines @@
     // Seed storage with expected manifest response info that will cause
     // an If-Modified-Since header to be put in the manifest fetch request.
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "Last-Modified: Sat, 29 Oct 1994 19:43:31 GMT\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->headers = headers;  // adds ref to headers
-    scoped_refptr<HttpResponseInfoIOBuffer> io_buffer =
-        new HttpResponseInfoIOBuffer(response_info);  // adds ref to info
+    scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
+        new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     write_callback_.reset(
         new net::CompletionCallbackImpl<AppCacheUpdateJobTest>(this,
             &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
     response_writer_->WriteInfo(io_buffer, write_callback_.get());
 
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchUpgradeTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
@@ skipping 36 matching lines @@
     // Seed storage with expected manifest response info that will cause
     // an If-None-Match header to be put in the manifest fetch request.
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "ETag: \"LadeDade\"\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->headers = headers;  // adds ref to headers
-    scoped_refptr<HttpResponseInfoIOBuffer> io_buffer =
-        new HttpResponseInfoIOBuffer(response_info);  // adds ref to info
+    scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
+        new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     write_callback_.reset(
         new net::CompletionCallbackImpl<AppCacheUpdateJobTest>(this,
             &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
     response_writer_->WriteInfo(io_buffer, write_callback_.get());
 
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchRefetchTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
@@ skipping 129 matching lines @@
     AppCacheHost* host = new AppCacheHost(host_id, frontend, service_.get());
     hosts_.push_back(host);
     return host;
   }
 
   AppCacheResponseInfo* MakeAppCacheResponseInfo(
       const GURL& manifest_url, int64 response_id,
       const std::string& raw_headers) {
     net::HttpResponseInfo* http_info = new net::HttpResponseInfo();
     http_info->headers = new net::HttpResponseHeaders(raw_headers);
-    scoped_refptr<AppCacheResponseInfo> info =
+    scoped_refptr<AppCacheResponseInfo> info(
         new AppCacheResponseInfo(service_.get(), manifest_url,
-                                 response_id, http_info, 0);
+                                 response_id, http_info, 0));
     response_infos_.push_back(info);
     return info;
   }
 
   MockFrontend* MakeMockFrontend() {
     MockFrontend* frontend = new MockFrontend();
     frontends_.push_back(frontend);
     return frontend;
   }
 
@@ skipping 301 matching lines @@
   URLRequest::ProtocolFactory* old_factory_;
 };
 
 // static
 IOThread* AppCacheUpdateJobTest::io_thread_ = NULL;
 base::WaitableEvent* AppCacheUpdateJobTest::io_thread_shutdown_event_ = NULL;
 
 
 TEST_F(AppCacheUpdateJobTest, AlreadyChecking) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheGroup> group =
+  scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(&service, GURL("http://manifesturl.com"),
-                        service.storage()->NewGroupId());
+                        service.storage()->NewGroupId()));
 
   AppCacheUpdateJob update(&service, group);
 
   // Pretend group is in checking state.
   group->update_job_ = &update;
   group->update_status_ = AppCacheGroup::CHECKING;
 
   update.StartUpdate(NULL, GURL());
   EXPECT_EQ(AppCacheGroup::CHECKING, group->update_status());
 
   MockFrontend mock_frontend;
   AppCacheHost host(1, &mock_frontend, &service);
   update.StartUpdate(&host, GURL());
 
   MockFrontend::RaisedEvents events = mock_frontend.raised_events_;
   size_t expected = 1;
   EXPECT_EQ(expected, events.size());
   EXPECT_EQ(expected, events[0].first.size());
   EXPECT_EQ(host.host_id(), events[0].first[0]);
   EXPECT_EQ(CHECKING_EVENT, events[0].second);
   EXPECT_EQ(AppCacheGroup::CHECKING, group->update_status());
 }
 
 TEST_F(AppCacheUpdateJobTest, AlreadyDownloading) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheGroup> group =
+  scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(&service, GURL("http://manifesturl.com"),
-                        service.storage()->NewGroupId());
+                        service.storage()->NewGroupId()));
 
   AppCacheUpdateJob update(&service, group);
 
   // Pretend group is in downloading state.
   group->update_job_ = &update;
   group->update_status_ = AppCacheGroup::DOWNLOADING;
 
   update.StartUpdate(NULL, GURL());
   EXPECT_EQ(AppCacheGroup::DOWNLOADING, group->update_status());
 
@@ skipping 226 matching lines @@
   RunTestOnIOThread(&AppCacheUpdateJobTest::MultipleHeadersRefetchTest);
 }
 
 }  // namespace appcache
 
 // AppCacheUpdateJobTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheUpdateJobTest);
 DISABLE_RUNNABLE_METHOD_REFCOUNT(
     appcache::AppCacheUpdateJobTest::MockAppCachePolicy);