Convert implicit scoped_refptr constructor calls to explicit ones, part 1

webkit/appcache/appcache_storage_impl.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 "webkit/appcache/appcache_storage_impl.h"
 
 #include "app/sql/connection.h"
 #include "app/sql/transaction.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 857 matching lines @@
                                      base::MessageLoopProxy* cache_thread) {
   cache_directory_ = cache_directory;
   cache_thread_ = cache_thread;
   is_incognito_ = cache_directory_.empty();
 
   FilePath db_file_path;
   if (!is_incognito_)
     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();
 }
 
 void AppCacheStorageImpl::Disable() {
   if (is_disabled_)
     return;
   VLOG(1) << "Disabling appcache storage.";
   is_disabled_ = true;
   origins_with_groups_.clear();
   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();
 }
 
 void AppCacheStorageImpl::LoadCache(int64 id, Delegate* delegate) {
   DCHECK(delegate);
   if (is_disabled_) {
     delegate->OnCacheLoaded(NULL, id);
     return;
   }
 
   AppCache* cache = working_set_.GetCache(id);
   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;
   }
   task = new CacheLoadTask(id, this);
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
   pending_cache_loads_[id] = task;
 }
 
 void AppCacheStorageImpl::LoadOrCreateGroup(
     const GURL& manifest_url, Delegate* delegate) {
   DCHECK(delegate);
   if (is_disabled_) {
     delegate->OnGroupLoaded(NULL, manifest_url);
     return;
   }
 
   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;
   }
 
   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;
   }
 
   task = new GroupLoadTask(manifest_url, this);
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
   pending_group_loads_[manifest_url] = task.get();
 }
 
 void AppCacheStorageImpl::StoreGroupAndNewestCache(
     AppCacheGroup* group, AppCache* newest_cache, Delegate* delegate) {
   // TODO(michaeln): distinguish between a simple update of an existing
   // cache that just adds new master entry(s), and the insertion of a
   // whole new cache. The StoreGroupAndCacheTask as written will handle
   // 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();
 }
 
 void AppCacheStorageImpl::FindResponseForMainRequest(
     const GURL& url, Delegate* delegate) {
   DCHECK(delegate);
 
   const GURL* url_ptr = &url;
   GURL url_no_ref;
@@ skipping 37 matching lines @@
     scoped_refptr<AppCacheGroup> no_group;
     scoped_refptr<AppCache> no_cache;
     ScheduleSimpleTask(method_factory_.NewRunnableMethod(
         &AppCacheStorageImpl::DeliverShortCircuitedFindMainResponse,
         url, AppCacheEntry(), no_group, no_cache,
         make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
     return;
   }
 
   // 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();
 }
 
 void AppCacheStorageImpl::DeliverShortCircuitedFindMainResponse(
     const GURL& url, AppCacheEntry found_entry,
     scoped_refptr<AppCacheGroup> group, scoped_refptr<AppCache> cache,
     scoped_refptr<DelegateReference> delegate_ref) {
   if (delegate_ref->delegate) {
     DelegateReferenceVector delegates(1, delegate_ref);
@@ skipping 50 matching lines @@
 
 void AppCacheStorageImpl::MarkEntryAsForeign(
     const GURL& entry_url, int64 cache_id) {
   AppCache* cache = working_set_.GetCache(cache_id);
   if (cache) {
     AppCacheEntry* entry = cache->GetEntry(entry_url);
     DCHECK(entry);
     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));
 }
 
 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();
 }
 
 AppCacheResponseReader* AppCacheStorageImpl::CreateResponseReader(
     const GURL& manifest_url, int64 response_id) {
   return new AppCacheResponseReader(response_id, disk_cache());
 }
 
 AppCacheResponseWriter* AppCacheStorageImpl::CreateResponseWriter(
     const GURL& manifest_url) {
   return new AppCacheResponseWriter(NewResponseId(), disk_cache());
 }
 
 void AppCacheStorageImpl::DoomResponses(
     const GURL& manifest_url, const std::vector<int64>& response_ids) {
   if (response_ids.empty())
     return;
 
   // Start deleting them from the disk cache lazily.
   StartDeletingResponses(response_ids);
 
   // Also schedule a database task to record these ids in the
   // deletable responses table.
   // 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();
 }
 
 void AppCacheStorageImpl::DeleteResponses(
     const GURL& manifest_url, const std::vector<int64>& response_ids) {
   if (response_ids.empty())
     return;
   StartDeletingResponses(response_ids);
 }
 
 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();
   }
 }
 
 void AppCacheStorageImpl::StartDeletingResponses(
     const std::vector<int64>& response_ids) {
   DCHECK(!response_ids.empty());
   did_start_deleting_responses_ = true;
   deletable_response_ids_.insert(
       deletable_response_ids_.end(),
@@ skipping 36 matching lines @@
     return;
 
   int64 id = deletable_response_ids_.front();
   deletable_response_ids_.pop_front();
   if (rv != net::ERR_ABORTED)
     deleted_response_ids_.push_back(id);
 
   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;
   }
 
   ScheduleDeleteOneResponse();
 }
 
 AppCacheStorageImpl::CacheLoadTask*
 AppCacheStorageImpl::GetPendingCacheLoadTask(int64 cache_id) {
   PendingCacheLoads::iterator found = pending_cache_loads_.find(cache_id);
@@ skipping 74 matching lines @@
     Disable();
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
       AppCacheThread::PostTask(AppCacheThread::db(), FROM_HERE,
           NewRunnableFunction(DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache