Convert implicit scoped_refptr constructor calls to explicit ones, part 1

This CL was created automatically by this clang rewriter: http://codereview.appspot.com/2776043/ . I manually fixed a few rough spots of the rewriter output (doh1-3) and fixed all presubmit errors.

BUG=28083
TEST=None

Review URL: http://codereview.chromium.org/4192012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@64573 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 119 insertions, 119 deletions

diff --git a/webkit/appcache/appcache_group_unittest.cc b/webkit/appcache/appcache_group_unittest.cc
index 128fbc7..c42722c 100644
--- a/webkit/appcache/appcache_group_unittest.cc
+++ b/webkit/appcache/appcache_group_unittest.cc
@@ -99,39 +99,39 @@ class AppCacheGroupTest : public testing::Test {
 
 TEST(AppCacheGroupTest, AddRemoveCache) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, GURL("http://foo.com"), 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   base::Time now = base::Time::Now();
 
-  scoped_refptr<AppCache> cache1 = new AppCache(&service, 111);
+  scoped_refptr<AppCache> cache1(new AppCache(&service, 111));
   cache1->set_complete(true);
   cache1->set_update_time(now);
   group->AddCache(cache1);
   EXPECT_EQ(cache1, group->newest_complete_cache());
 
   // Adding older cache does not change newest complete cache.
-  scoped_refptr<AppCache> cache2 = new AppCache(&service, 222);
+  scoped_refptr<AppCache> cache2(new AppCache(&service, 222));
   cache2->set_complete(true);
   cache2->set_update_time(now - base::TimeDelta::FromDays(1));
   group->AddCache(cache2);
   EXPECT_EQ(cache1, group->newest_complete_cache());
 
   // Adding newer cache does change newest complete cache.
-  scoped_refptr<AppCache> cache3 = new AppCache(&service, 333);
+  scoped_refptr<AppCache> cache3(new AppCache(&service, 333));
   cache3->set_complete(true);
   cache3->set_update_time(now + base::TimeDelta::FromDays(1));
   group->AddCache(cache3);
   EXPECT_EQ(cache3, group->newest_complete_cache());
 
   // Adding cache with same update time uses one with larger ID.
-  scoped_refptr<AppCache> cache4 = new AppCache(&service, 444);
+  scoped_refptr<AppCache> cache4(new AppCache(&service, 444));
   cache4->set_complete(true);
   cache4->set_update_time(now + base::TimeDelta::FromDays(1));  // same as 3
   group->AddCache(cache4);
   EXPECT_EQ(cache4, group->newest_complete_cache());
 
-  scoped_refptr<AppCache> cache5 = new AppCache(&service, 55);  // smaller id
+  scoped_refptr<AppCache> cache5(new AppCache(&service, 55));  // smaller id
   cache5->set_complete(true);
   cache5->set_update_time(now + base::TimeDelta::FromDays(1));  // same as 4
   group->AddCache(cache5);
@@ -209,8 +209,8 @@ TEST(AppCacheGroupTest, CleanupUnusedGroup) {
 
 TEST(AppCacheGroupTest, StartUpdate) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, GURL("http://foo.com"), 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   // Set state to checking to prevent update job from executing fetches.
   group->update_status_ = AppCacheGroup::CHECKING;
@@ -230,8 +230,8 @@ TEST(AppCacheGroupTest, StartUpdate) {
 
 TEST(AppCacheGroupTest, CancelUpdate) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, GURL("http://foo.com"), 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   // Set state to checking to prevent update job from executing fetches.
   group->update_status_ = AppCacheGroup::CHECKING;
@@ -249,8 +249,8 @@ TEST(AppCacheGroupTest, CancelUpdate) {
 
 TEST(AppCacheGroupTest, QueueUpdate) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, GURL("http://foo.com"), 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   // Set state to checking to prevent update job from executing fetches.
   group->update_status_ = AppCacheGroup::CHECKING;
diff --git a/webkit/appcache/appcache_host_unittest.cc b/webkit/appcache/appcache_host_unittest.cc
index 4f83928..5d1f409 100644
--- a/webkit/appcache/appcache_host_unittest.cc
+++ b/webkit/appcache/appcache_host_unittest.cc
@@ -255,8 +255,8 @@ TEST_F(AppCacheHostTest, SetSwappableCache) {
   host.SetSwappableCache(NULL);
   EXPECT_FALSE(host.swappable_cache_.get());
 
-  scoped_refptr<AppCacheGroup> group1 =
-      new AppCacheGroup(&service_, GURL(), service_.storage()->NewGroupId());
+  scoped_refptr<AppCacheGroup> group1(
+      new AppCacheGroup(&service_, GURL(), service_.storage()->NewGroupId()));
   host.SetSwappableCache(group1);
   EXPECT_FALSE(host.swappable_cache_.get());
 
@@ -281,9 +281,9 @@ TEST_F(AppCacheHostTest, SetSwappableCache) {
   group1->AddCache(cache2);
   EXPECT_EQ(cache2, host.swappable_cache_.get());  // updated to newest
 
-  scoped_refptr<AppCacheGroup> group2 =
+  scoped_refptr<AppCacheGroup> group2(
       new AppCacheGroup(&service_, GURL("http://foo.com"),
-                        service_.storage()->NewGroupId());
+                        service_.storage()->NewGroupId()));
   AppCache* cache3 = new AppCache(&service_, 333);
   cache3->set_complete(true);
   group2->AddCache(cache3);
diff --git a/webkit/appcache/appcache_response_unittest.cc b/webkit/appcache/appcache_response_unittest.cc
index bef5b4d0..3c5f692 100644
--- a/webkit/appcache/appcache_response_unittest.cc
+++ b/webkit/appcache/appcache_response_unittest.cc
@@ -172,7 +172,7 @@ class AppCacheResponseTest : public testing::Test {
     static const char kHttpHeaders[] =
         "HTTP/1.0 200 OK\0Content-Length: 5\0\0";
     static const char* kHttpBody = "Hello";
-    scoped_refptr<IOBuffer> body = new WrappedIOBuffer(kHttpBody);
+    scoped_refptr<IOBuffer> body(new WrappedIOBuffer(kHttpBody));
     std::string raw_headers(kHttpHeaders, arraysize(kHttpHeaders));
     WriteResponse(MakeHttpResponseInfo(raw_headers), body, strlen(kHttpBody));
   }
@@ -456,8 +456,8 @@ class AppCacheResponseTest : public testing::Test {
   }
 
   void WriteOneBlock(int block_number) {
-    scoped_refptr<IOBuffer> io_buffer =
-        new IOBuffer(kBlockSize);
+    scoped_refptr<IOBuffer> io_buffer(
+        new IOBuffer(kBlockSize));
     FillData(block_number, io_buffer->data(), kBlockSize);
     WriteResponseBody(io_buffer, kBlockSize);
   }
diff --git a/webkit/appcache/appcache_storage_impl.cc b/webkit/appcache/appcache_storage_impl.cc
index 518f840..232dffb 100644
--- a/webkit/appcache/appcache_storage_impl.cc
+++ b/webkit/appcache/appcache_storage_impl.cc
@@ -875,7 +875,7 @@ void AppCacheStorageImpl::Initialize(const FilePath& cache_directory,
     db_file_path = cache_directory_.Append(kAppCacheDatabaseName);
   database_ = new AppCacheDatabase(db_file_path);
 
-  scoped_refptr<InitTask> task = new InitTask(this);
+  scoped_refptr<InitTask> task(new InitTask(this));
   task->Schedule();
 }
 
@@ -888,13 +888,13 @@ void AppCacheStorageImpl::Disable() {
   working_set()->Disable();
   if (disk_cache_.get())
     disk_cache_->Disable();
-  scoped_refptr<DisableDatabaseTask> task = new DisableDatabaseTask(this);
+  scoped_refptr<DisableDatabaseTask> task(new DisableDatabaseTask(this));
   task->Schedule();
 }
 
 void AppCacheStorageImpl::GetAllInfo(Delegate* delegate) {
   DCHECK(delegate);
-  scoped_refptr<GetAllInfoTask> task = new GetAllInfoTask(this);
+  scoped_refptr<GetAllInfoTask> task(new GetAllInfoTask(this));
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
 }
@@ -910,14 +910,14 @@ void AppCacheStorageImpl::LoadCache(int64 id, Delegate* delegate) {
   if (cache) {
     delegate->OnCacheLoaded(cache, id);
     if (cache->owning_group()) {
-      scoped_refptr<DatabaseTask> update_task =
+      scoped_refptr<DatabaseTask> update_task(
           new UpdateGroupLastAccessTimeTask(
-              this, cache->owning_group()->group_id(), base::Time::Now());
+              this, cache->owning_group()->group_id(), base::Time::Now()));
       update_task->Schedule();
     }
     return;
   }
-  scoped_refptr<CacheLoadTask> task = GetPendingCacheLoadTask(id);
+  scoped_refptr<CacheLoadTask> task(GetPendingCacheLoadTask(id));
   if (task) {
     task->AddDelegate(GetOrCreateDelegateReference(delegate));
     return;
@@ -939,14 +939,14 @@ void AppCacheStorageImpl::LoadOrCreateGroup(
   AppCacheGroup* group = working_set_.GetGroup(manifest_url);
   if (group) {
     delegate->OnGroupLoaded(group, manifest_url);
-    scoped_refptr<DatabaseTask> update_task =
+    scoped_refptr<DatabaseTask> update_task(
         new UpdateGroupLastAccessTimeTask(
-            this, group->group_id(), base::Time::Now());
+            this, group->group_id(), base::Time::Now()));
     update_task->Schedule();
     return;
   }
 
-  scoped_refptr<GroupLoadTask> task = GetPendingGroupLoadTask(manifest_url);
+  scoped_refptr<GroupLoadTask> task(GetPendingGroupLoadTask(manifest_url));
   if (task) {
     task->AddDelegate(GetOrCreateDelegateReference(delegate));
     return;
@@ -955,8 +955,8 @@ void AppCacheStorageImpl::LoadOrCreateGroup(
   if (origins_with_groups_.find(manifest_url.GetOrigin()) ==
       origins_with_groups_.end()) {
     // No need to query the database, return a new group immediately.
-    scoped_refptr<AppCacheGroup> group = new AppCacheGroup(
-        service_, manifest_url, NewGroupId());
+    scoped_refptr<AppCacheGroup> group(new AppCacheGroup(
+        service_, manifest_url, NewGroupId()));
     delegate->OnGroupLoaded(group, manifest_url);
     return;
   }
@@ -975,8 +975,8 @@ void AppCacheStorageImpl::StoreGroupAndNewestCache(
   // the simple update case in a very heavy weight way (delete all and
   // the reinsert all over again).
   DCHECK(group && delegate && newest_cache);
-  scoped_refptr<StoreGroupAndCacheTask> task =
-      new StoreGroupAndCacheTask(this, group, newest_cache);
+  scoped_refptr<StoreGroupAndCacheTask> task(
+      new StoreGroupAndCacheTask(this, group, newest_cache));
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
 }
@@ -1034,8 +1034,8 @@ void AppCacheStorageImpl::FindResponseForMainRequest(
   }
 
   // We have to query the database, schedule a database task to do so.
-  scoped_refptr<FindMainResponseTask> task =
-      new FindMainResponseTask(this, *url_ptr, groups_in_use);
+  scoped_refptr<FindMainResponseTask> task(
+      new FindMainResponseTask(this, *url_ptr, groups_in_use));
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
 }
@@ -1106,8 +1106,8 @@ void AppCacheStorageImpl::MarkEntryAsForeign(
     if (entry)
       entry->add_types(AppCacheEntry::FOREIGN);
   }
-  scoped_refptr<MarkEntryAsForeignTask> task =
-      new MarkEntryAsForeignTask(this, entry_url, cache_id);
+  scoped_refptr<MarkEntryAsForeignTask> task(
+      new MarkEntryAsForeignTask(this, entry_url, cache_id));
   task->Schedule();
   pending_foreign_markings_.push_back(std::make_pair(entry_url, cache_id));
 }
@@ -1115,8 +1115,8 @@ void AppCacheStorageImpl::MarkEntryAsForeign(
 void AppCacheStorageImpl::MakeGroupObsolete(
     AppCacheGroup* group, Delegate* delegate) {
   DCHECK(group && delegate);
-  scoped_refptr<MakeGroupObsoleteTask> task =
-      new MakeGroupObsoleteTask(this, group);
+  scoped_refptr<MakeGroupObsoleteTask> task(
+      new MakeGroupObsoleteTask(this, group));
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
 }
@@ -1144,8 +1144,8 @@ void AppCacheStorageImpl::DoomResponses(
   // TODO(michaeln): There is a race here. If the browser crashes
   // prior to committing these rows to the database and prior to us
   // having deleted them from the disk cache, we'll never delete them.
-  scoped_refptr<InsertDeletableResponseIdsTask> task =
-      new InsertDeletableResponseIdsTask(this);
+  scoped_refptr<InsertDeletableResponseIdsTask> task(
+      new InsertDeletableResponseIdsTask(this));
   task->response_ids_ = response_ids;
   task->Schedule();
 }
@@ -1158,15 +1158,15 @@ void AppCacheStorageImpl::DeleteResponses(
 }
 
 void AppCacheStorageImpl::PurgeMemory() {
-  scoped_refptr<CloseConnectionTask> task = new CloseConnectionTask(this);
+  scoped_refptr<CloseConnectionTask> task(new CloseConnectionTask(this));
   task->Schedule();
 }
 
 void AppCacheStorageImpl::DelayedStartDeletingUnusedResponses() {
   // Only if we haven't already begun.
   if (!did_start_deleting_responses_) {
-    scoped_refptr<GetDeletableResponseIdsTask> task =
-        new GetDeletableResponseIdsTask(this, last_deletable_response_rowid_);
+    scoped_refptr<GetDeletableResponseIdsTask> task(
+        new GetDeletableResponseIdsTask(this, last_deletable_response_rowid_));
     task->Schedule();
   }
 }
@@ -1223,15 +1223,15 @@ void AppCacheStorageImpl::OnDeletedOneResponse(int rv) {
   const size_t kBatchSize = 50U;
   if (deleted_response_ids_.size() >= kBatchSize ||
       deletable_response_ids_.empty()) {
-    scoped_refptr<DeleteDeletableResponseIdsTask> task =
-        new DeleteDeletableResponseIdsTask(this);
+    scoped_refptr<DeleteDeletableResponseIdsTask> task(
+        new DeleteDeletableResponseIdsTask(this));
     task->response_ids_.swap(deleted_response_ids_);
     task->Schedule();
   }
 
   if (deletable_response_ids_.empty()) {
-    scoped_refptr<GetDeletableResponseIdsTask> task =
-        new GetDeletableResponseIdsTask(this, last_deletable_response_rowid_);
+    scoped_refptr<GetDeletableResponseIdsTask> task(
+        new GetDeletableResponseIdsTask(this, last_deletable_response_rowid_));
     task->Schedule();
     return;
   }
diff --git a/webkit/appcache/appcache_storage_impl_unittest.cc b/webkit/appcache/appcache_storage_impl_unittest.cc
index 5fccade..6c153a5 100644
--- a/webkit/appcache/appcache_storage_impl_unittest.cc
+++ b/webkit/appcache/appcache_storage_impl_unittest.cc
@@ -316,7 +316,7 @@ class AppCacheStorageImplTest : public testing::Test {
     // Setup some preconditions. Make an 'unstored' cache for
     // us to load. The ctor should put it in the working set.
     int64 cache_id = storage()->NewCacheId();
-    scoped_refptr<AppCache> cache = new AppCache(service(), cache_id);
+    scoped_refptr<AppCache> cache(new AppCache(service(), cache_id));
 
     // Conduct the test.
     storage()->LoadCache(cache_id, delegate());
diff --git a/webkit/appcache/appcache_storage_unittest.cc b/webkit/appcache/appcache_storage_unittest.cc
index bdb1111..9e9e57e 100644
--- a/webkit/appcache/appcache_storage_unittest.cc
+++ b/webkit/appcache/appcache_storage_unittest.cc
@@ -21,7 +21,7 @@ class AppCacheStorageTest : public testing::Test {
 
 TEST_F(AppCacheStorageTest, AddRemoveCache) {
   MockAppCacheService service;
-  scoped_refptr<AppCache> cache = new AppCache(&service, 111);
+  scoped_refptr<AppCache> cache(new AppCache(&service, 111));
 
   EXPECT_EQ(cache.get(),
             service.storage()->working_set()->GetCache(111));
@@ -37,7 +37,7 @@ TEST_F(AppCacheStorageTest, AddRemoveCache) {
 
 TEST_F(AppCacheStorageTest, AddRemoveGroup) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheGroup> group = new AppCacheGroup(&service, GURL(), 111);
+  scoped_refptr<AppCacheGroup> group(new AppCacheGroup(&service, GURL(), 111));
 
   EXPECT_EQ(group.get(), service.storage()->working_set()->GetGroup(GURL()));
 
@@ -52,10 +52,10 @@ TEST_F(AppCacheStorageTest, AddRemoveGroup) {
 
 TEST_F(AppCacheStorageTest, AddRemoveResponseInfo) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheResponseInfo> info =
+  scoped_refptr<AppCacheResponseInfo> info(
       new AppCacheResponseInfo(&service, GURL(),
                                111, new net::HttpResponseInfo,
-                               kUnkownResponseDataSize);
+                               kUnkownResponseDataSize));
 
   EXPECT_EQ(info.get(),
             service.storage()->working_set()->GetResponseInfo(111));
diff --git a/webkit/appcache/appcache_unittest.cc b/webkit/appcache/appcache_unittest.cc
index 8fcde53..d0583f8 100644
--- a/webkit/appcache/appcache_unittest.cc
+++ b/webkit/appcache/appcache_unittest.cc
@@ -34,7 +34,7 @@ TEST(AppCacheTest, CleanupUnusedCache) {
 
 TEST(AppCacheTest, AddModifyRemoveEntry) {
   MockAppCacheService service;
-  scoped_refptr<AppCache> cache = new AppCache(&service, 111);
+  scoped_refptr<AppCache> cache(new AppCache(&service, 111));
 
   EXPECT_TRUE(cache->entries().empty());
   EXPECT_EQ(0L, cache->cache_size());
@@ -79,7 +79,7 @@ TEST(AppCacheTest, AddModifyRemoveEntry) {
 TEST(AppCacheTest, InitializeWithManifest) {
   MockAppCacheService service;
 
-  scoped_refptr<AppCache> cache = new AppCache(&service, 1234);
+  scoped_refptr<AppCache> cache(new AppCache(&service, 1234));
   EXPECT_TRUE(cache->fallback_namespaces_.empty());
   EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
   EXPECT_FALSE(cache->online_whitelist_all_);
@@ -144,7 +144,7 @@ TEST(AppCacheTest, FindResponseForRequest) {
       FallbackNamespace(kFallbackNamespaceUrl2, kFallbackEntryUrl2));
 
   // Create a cache with some namespaces and entries.
-  scoped_refptr<AppCache> cache = new AppCache(&service, 1234);
+  scoped_refptr<AppCache> cache(new AppCache(&service, 1234));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kFallbackEntryUrl1,
diff --git a/webkit/appcache/appcache_update_job.cc b/webkit/appcache/appcache_update_job.cc
index 3aeb497..94d8a05 100644
--- a/webkit/appcache/appcache_update_job.cc
+++ b/webkit/appcache/appcache_update_job.cc
@@ -353,9 +353,9 @@ void AppCacheUpdateJob::OnResponseStarted(URLRequest *request) {
           service_->storage()->CreateResponseWriter(manifest_url_),
           this, request);
       stored_response_ids_.push_back(info->response_writer_->response_id());
-      scoped_refptr<HttpResponseInfoIOBuffer> io_buffer =
+      scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
           new HttpResponseInfoIOBuffer(
-              new net::HttpResponseInfo(request->response_info()));
+              new net::HttpResponseInfo(request->response_info())));
       info->response_writer_->WriteInfo(io_buffer, &info->write_callback_);
     } else {
       ReadResponseData(request);
@@ -782,8 +782,8 @@ void AppCacheUpdateJob::HandleManifestRefetchCompleted(URLRequest* request) {
       manifest_response_writer_.reset(
           service_->storage()->CreateResponseWriter(manifest_url_));
       stored_response_ids_.push_back(manifest_response_writer_->response_id());
-      scoped_refptr<HttpResponseInfoIOBuffer> io_buffer =
-          new HttpResponseInfoIOBuffer(manifest_response_info_.release());
+      scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
+          new HttpResponseInfoIOBuffer(manifest_response_info_.release()));
       manifest_response_writer_->WriteInfo(io_buffer,
                                            &manifest_info_write_callback_);
     }
@@ -798,8 +798,8 @@ void AppCacheUpdateJob::HandleManifestRefetchCompleted(URLRequest* request) {
 
 void AppCacheUpdateJob::OnManifestInfoWriteComplete(int result) {
   if (result > 0) {
-    scoped_refptr<net::StringIOBuffer> io_buffer =
-        new net::StringIOBuffer(manifest_data_);
+    scoped_refptr<net::StringIOBuffer> io_buffer(
+        new net::StringIOBuffer(manifest_data_));
     manifest_response_writer_->WriteData(io_buffer, manifest_data_.length(),
                                          &manifest_data_write_callback_);
   } else {
diff --git a/webkit/appcache/appcache_update_job_unittest.cc b/webkit/appcache/appcache_update_job_unittest.cc
index 948c8a0..eddb8e4 100644
--- a/webkit/appcache/appcache_update_job_unittest.cc
+++ b/webkit/appcache/appcache_update_job_unittest.cc
@@ -997,8 +997,8 @@ class AppCacheUpdateJobTest : public testing::Test,
 
     // 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));
@@ -1100,8 +1100,8 @@ class AppCacheUpdateJobTest : public testing::Test,
 
     // 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));
@@ -1162,8 +1162,8 @@ class AppCacheUpdateJobTest : public testing::Test,
     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));
@@ -1220,8 +1220,8 @@ class AppCacheUpdateJobTest : public testing::Test,
     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));
@@ -1278,8 +1278,8 @@ class AppCacheUpdateJobTest : public testing::Test,
     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));
@@ -1829,9 +1829,9 @@ class AppCacheUpdateJobTest : public testing::Test,
     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);
@@ -2686,8 +2686,8 @@ class AppCacheUpdateJobTest : public testing::Test,
         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));
@@ -2744,8 +2744,8 @@ class AppCacheUpdateJobTest : public testing::Test,
         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));
@@ -2895,9 +2895,9 @@ class AppCacheUpdateJobTest : public testing::Test,
       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;
   }
@@ -3219,9 +3219,9 @@ 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);
 
@@ -3247,9 +3247,9 @@ TEST_F(AppCacheUpdateJobTest, AlreadyChecking) {
 
 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);
 
diff --git a/webkit/appcache/appcache_url_request_job_unittest.cc b/webkit/appcache/appcache_url_request_job_unittest.cc
index f3a3ed2..2475c79 100644
--- a/webkit/appcache/appcache_url_request_job_unittest.cc
+++ b/webkit/appcache/appcache_url_request_job_unittest.cc
@@ -104,8 +104,8 @@ class AppCacheURLRequestJobTest : public testing::Test {
 
     void ReadSome(URLRequest* request) {
       DCHECK(amount_received_ + kBlockSize <= kNumBlocks * kBlockSize);
-      scoped_refptr<IOBuffer> wrapped_buffer =
-          new net::WrappedIOBuffer(received_data_->data() + amount_received_);
+      scoped_refptr<IOBuffer> wrapped_buffer(
+          new net::WrappedIOBuffer(received_data_->data() + amount_received_));
       int bytes_read = 0;
       EXPECT_FALSE(request->Read(wrapped_buffer, kBlockSize, &bytes_read));
       EXPECT_EQ(0, bytes_read);
@@ -264,7 +264,7 @@ class AppCacheURLRequestJobTest : public testing::Test {
   // Wrappers to call AppCacheResponseReader/Writer Read and Write methods
 
   void WriteBasicResponse() {
-    scoped_refptr<IOBuffer> body = new WrappedIOBuffer(kHttpBasicBody);
+    scoped_refptr<IOBuffer> body(new WrappedIOBuffer(kHttpBasicBody));
     std::string raw_headers(kHttpBasicHeaders, arraysize(kHttpBasicHeaders));
     WriteResponse(MakeHttpResponseInfo(raw_headers), body,
                   strlen(kHttpBasicBody));
@@ -603,7 +603,7 @@ class AppCacheURLRequestJobTest : public testing::Test {
     // 3, 1k blocks
     static const char kHttpHeaders[] =
         "HTTP/1.0 200 OK\0Content-Length: 3072\0\0";
-    scoped_refptr<IOBuffer> body = new IOBuffer(kBlockSize * 3);
+    scoped_refptr<IOBuffer> body(new IOBuffer(kBlockSize * 3));
     char* p = body->data();
     for (int i = 0; i < 3; ++i, p += kBlockSize)
       FillData(i + 1, p, kBlockSize);
diff --git a/webkit/appcache/mock_appcache_storage.cc b/webkit/appcache/mock_appcache_storage.cc
index 6bf3e8d..a50dca6 100644
--- a/webkit/appcache/mock_appcache_storage.cc
+++ b/webkit/appcache/mock_appcache_storage.cc
@@ -171,7 +171,7 @@ void MockAppCacheStorage::ProcessLoadCache(
 
 void MockAppCacheStorage::ProcessLoadOrCreateGroup(
     const GURL& manifest_url, scoped_refptr<DelegateReference> delegate_ref) {
-  scoped_refptr<AppCacheGroup> group = working_set_.GetGroup(manifest_url);
+  scoped_refptr<AppCacheGroup> group(working_set_.GetGroup(manifest_url));
 
   // Newly created groups are not put in the stored_groups collection
   // until StoreGroupAndNewestCache is called.
diff --git a/webkit/appcache/mock_appcache_storage_unittest.cc b/webkit/appcache/mock_appcache_storage_unittest.cc
index 5be333a..3bd8ca6 100644
--- a/webkit/appcache/mock_appcache_storage_unittest.cc
+++ b/webkit/appcache/mock_appcache_storage_unittest.cc
@@ -92,7 +92,7 @@ TEST_F(MockAppCacheStorageTest, LoadCache_NearHit) {
   // Setup some preconditions. Make an 'unstored' cache for
   // us to load. The ctor should put it in the working set.
   int64 cache_id = service.storage()->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
 
   // Conduct the test.
   MockStorageDelegate delegate;
@@ -157,10 +157,10 @@ TEST_F(MockAppCacheStorageTest, LoadGroupAndCache_FarHit) {
   // Setup some preconditions. Create a group and newest cache that
   // appears to be "stored" and "not currently in use".
   GURL manifest_url("http://blah/");
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, manifest_url, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
   cache->set_complete(true);
   group->AddCache(cache);
   storage->AddStoredGroup(group);
@@ -208,10 +208,10 @@ TEST_F(MockAppCacheStorageTest, StoreNewGroup) {
   // Setup some preconditions. Create a group and newest cache that
   // appears to be "unstored".
   GURL manifest_url("http://blah/");
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, manifest_url, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
   // Hold a ref to the cache simulate the UpdateJob holding that ref,
   // and hold a ref to the group to simulate the CacheHost holding that ref.
 
@@ -240,16 +240,16 @@ TEST_F(MockAppCacheStorageTest, StoreExistingGroup) {
   // Setup some preconditions. Create a group and old complete cache
   // that appear to be "stored", and a newest unstored complete cache.
   GURL manifest_url("http://blah/");
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, manifest_url, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, manifest_url, 111));
   int64 old_cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> old_cache = new AppCache(&service, old_cache_id);
+  scoped_refptr<AppCache> old_cache(new AppCache(&service, old_cache_id));
   old_cache->set_complete(true);
   group->AddCache(old_cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(old_cache);
   int64 new_cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> new_cache = new AppCache(&service, new_cache_id);
+  scoped_refptr<AppCache> new_cache(new AppCache(&service, new_cache_id));
   // Hold our refs to simulate the UpdateJob holding these refs.
 
   // Conduct the test.
@@ -283,10 +283,10 @@ TEST_F(MockAppCacheStorageTest, StoreExistingGroupExistingCache) {
   // Setup some preconditions. Create a group and a complete cache that
   // appear to be "stored".
   GURL manifest_url("http://blah");
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, manifest_url, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
   cache->set_complete(true);
   group->AddCache(cache);
   storage->AddStoredGroup(group);
@@ -325,10 +325,10 @@ TEST_F(MockAppCacheStorageTest, MakeGroupObsolete) {
   // Setup some preconditions. Create a group and newest cache that
   // appears to be "stored" and "currently in use".
   GURL manifest_url("http://blah/");
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, manifest_url, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
   cache->set_complete(true);
   group->AddCache(cache);
   storage->AddStoredGroup(group);
@@ -370,7 +370,7 @@ TEST_F(MockAppCacheStorageTest, MarkEntryAsForeign) {
   // Setup some preconditions. Create a cache with an entry.
   GURL entry_url("http://blah/entry");
   int64 cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
   cache->AddEntry(entry_url, AppCacheEntry(AppCacheEntry::EXPLICIT));
 
   // Conduct the test.
@@ -414,12 +414,12 @@ TEST_F(MockAppCacheStorageTest, BasicFindMainResponse) {
   const GURL kEntryUrl("http://blah/entry");
   const GURL kManifestUrl("http://blah/manifest");
   const int64 kResponseId = 1;
-  scoped_refptr<AppCache> cache = new AppCache(&service, kCacheId);
+  scoped_refptr<AppCache> cache(new AppCache(&service, kCacheId));
   cache->AddEntry(
       kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId));
   cache->set_complete(true);
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, kManifestUrl, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, kManifestUrl, 111));
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
@@ -461,7 +461,7 @@ TEST_F(MockAppCacheStorageTest, BasicFindMainFallbackResponse) {
   manifest.fallback_namespaces.push_back(
       FallbackNamespace(kFallbackNamespaceUrl2, kFallbackEntryUrl2));
 
-  scoped_refptr<AppCache> cache = new AppCache(&service, kCacheId);
+  scoped_refptr<AppCache> cache(new AppCache(&service, kCacheId));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kFallbackEntryUrl1, AppCacheEntry(AppCacheEntry::FALLBACK, kResponseId1));
@@ -469,8 +469,8 @@ TEST_F(MockAppCacheStorageTest, BasicFindMainFallbackResponse) {
       kFallbackEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, kResponseId2));
   cache->set_complete(true);
 
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, kManifestUrl, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, kManifestUrl, 111));
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
@@ -511,12 +511,12 @@ TEST_F(MockAppCacheStorageTest, FindMainResponseWithMultipleCandidates) {
   const int64 kResponseId2 = 2;
 
   // The first cache.
-  scoped_refptr<AppCache> cache = new AppCache(&service, kCacheId1);
+  scoped_refptr<AppCache> cache(new AppCache(&service, kCacheId1));
   cache->AddEntry(
       kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId1));
   cache->set_complete(true);
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, kManifestUrl1, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, kManifestUrl1, 111));
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
@@ -567,15 +567,15 @@ TEST_F(MockAppCacheStorageTest, FindMainResponseExclusions) {
   Manifest manifest;
   manifest.online_whitelist_namespaces.push_back(kOnlineNamespaceUrl);
 
-  scoped_refptr<AppCache> cache = new AppCache(&service, kCacheId);
+  scoped_refptr<AppCache> cache(new AppCache(&service, kCacheId));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kEntryUrl,
       AppCacheEntry(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN,
                     kResponseId));
   cache->set_complete(true);
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, kManifestUrl, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, kManifestUrl, 111));
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);