Remove implicit scoped_refptr operator T*

webkit/appcache/appcache_storage_impl.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 84 matching lines @@
   sql::Connection* connection = database->db_connection();
   if (!connection) {
     NOTREACHED() << "Missing database connection.";
     return;
   }
 
   std::set<GURL>::const_iterator origin;
   for (origin = origins.begin(); origin != origins.end(); ++origin) {
     if (!special_storage_policy->IsStorageSessionOnly(*origin))
       continue;
-    if (special_storage_policy &&
+    if (special_storage_policy.get() &&
         special_storage_policy->IsStorageProtected(*origin))
       continue;
 
     std::vector<AppCacheDatabase::GroupRecord> groups;
     database->FindGroupsForOrigin(*origin, &groups);
     std::vector<AppCacheDatabase::GroupRecord>::const_iterator group;
     for (group = groups.begin(); group != groups.end(); ++group) {
       sql::Transaction transaction(connection);
       if (!transaction.Begin()) {
         NOTREACHED() << "Failed to start transaction";
@@ skipping 246 matching lines @@
       info.cache_id = cache_record.cache_id;
       info.group_id = group->group_id;
       info.is_complete = true;
       infos.push_back(info);
     }
   }
 }
 
 void AppCacheStorageImpl::GetAllInfoTask::RunCompleted() {
   DCHECK(delegates_.size() == 1);
-  FOR_EACH_DELEGATE(delegates_, OnAllInfo(info_collection_));
+  FOR_EACH_DELEGATE(delegates_, OnAllInfo(info_collection_.get()));
 }
 
 // StoreOrLoadTask -------
 
 class AppCacheStorageImpl::StoreOrLoadTask : public DatabaseTask {
  protected:
   explicit StoreOrLoadTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
   virtual ~StoreOrLoadTask() {}
 
@@ skipping 123 matching lines @@
 }
 
 void AppCacheStorageImpl::CacheLoadTask::RunCompleted() {
   storage_->pending_cache_loads_.erase(cache_id_);
   scoped_refptr<AppCache> cache;
   scoped_refptr<AppCacheGroup> group;
   if (success_ && !storage_->is_disabled()) {
     DCHECK(cache_record_.cache_id == cache_id_);
     CreateCacheAndGroupFromRecords(&cache, &group);
   }
-  FOR_EACH_DELEGATE(delegates_, OnCacheLoaded(cache, cache_id_));
+  FOR_EACH_DELEGATE(delegates_, OnCacheLoaded(cache.get(), cache_id_));
 }
 
 // GroupLoadTask -------
 
 class AppCacheStorageImpl::GroupLoadTask : public StoreOrLoadTask {
  public:
   GroupLoadTask(GURL manifest_url, AppCacheStorageImpl* storage)
       : StoreOrLoadTask(storage), manifest_url_(manifest_url),
         success_(false) {}
 
@@ skipping 23 matching lines @@
 void AppCacheStorageImpl::GroupLoadTask::RunCompleted() {
   storage_->pending_group_loads_.erase(manifest_url_);
   scoped_refptr<AppCacheGroup> group;
   scoped_refptr<AppCache> cache;
   if (!storage_->is_disabled()) {
     if (success_) {
       DCHECK(group_record_.manifest_url == manifest_url_);
       CreateCacheAndGroupFromRecords(&cache, &group);
     } else {
       group = storage_->working_set_.GetGroup(manifest_url_);
-      if (!group) {
+      if (!group.get()) {
         group = new AppCacheGroup(
             storage_->service_, manifest_url_, storage_->NewGroupId());
       }
     }
   }
-  FOR_EACH_DELEGATE(delegates_, OnGroupLoaded(group, manifest_url_));
+  FOR_EACH_DELEGATE(delegates_, OnGroupLoaded(group.get(), manifest_url_));
 }
 
 // StoreGroupAndCacheTask -------
 
 class AppCacheStorageImpl::StoreGroupAndCacheTask : public StoreOrLoadTask {
  public:
   StoreGroupAndCacheTask(AppCacheStorageImpl* storage, AppCacheGroup* group,
                          AppCache* newest_cache);
 
   void GetQuotaThenSchedule();
@@ skipping 168 matching lines @@
     return;
   }
 
   success_ = transaction.Commit();
 }
 
 void AppCacheStorageImpl::StoreGroupAndCacheTask::RunCompleted() {
   if (success_) {
     storage_->UpdateUsageMapAndNotify(
         group_->manifest_url().GetOrigin(), new_origin_usage_);
-    if (cache_ != group_->newest_complete_cache()) {
+    if (cache_.get() != group_->newest_complete_cache()) {
       cache_->set_complete(true);
-      group_->AddCache(cache_);
+      group_->AddCache(cache_.get());
     }
     if (group_->creation_time().is_null())
       group_->set_creation_time(group_record_.creation_time);
     group_->AddNewlyDeletableResponseIds(&newly_deletable_response_ids_);
   }
   FOR_EACH_DELEGATE(delegates_,
-                    OnGroupAndNewestCacheStored(group_, cache_, success_,
-                                                would_exceed_quota_));
+                    OnGroupAndNewestCacheStored(
+                        group_.get(), cache_.get(), success_,
+                        would_exceed_quota_));
   group_ = NULL;
   cache_ = NULL;
 
   // TODO(michaeln): if (would_exceed_quota_) what if the current usage
   // also exceeds the quota? http://crbug.com/83968
 }
 
 void AppCacheStorageImpl::StoreGroupAndCacheTask::CancelCompletion() {
   // Overriden to safely drop our reference to the group and cache
   // which are not thread safe refcounted.
@@ skipping 385 matching lines @@
 void AppCacheStorageImpl::MakeGroupObsoleteTask::RunCompleted() {
   if (success_) {
     group_->set_obsolete(true);
     if (!storage_->is_disabled()) {
       storage_->UpdateUsageMapAndNotify(origin_, new_origin_usage_);
       group_->AddNewlyDeletableResponseIds(&newly_deletable_response_ids_);
 
       // Also remove from the working set, caches for an 'obsolete' group
       // may linger in use, but the group itself cannot be looked up by
       // 'manifest_url' in the working set any longer.
-      storage_->working_set()->RemoveGroup(group_);
+      storage_->working_set()->RemoveGroup(group_.get());
     }
   }
-  FOR_EACH_DELEGATE(delegates_, OnGroupMadeObsolete(group_, success_));
+  FOR_EACH_DELEGATE(delegates_, OnGroupMadeObsolete(group_.get(), success_));
   group_ = NULL;
 }
 
 void AppCacheStorageImpl::MakeGroupObsoleteTask::CancelCompletion() {
   // Overriden to safely drop our reference to the group
   // which is not thread safe refcounted.
   DatabaseTask::CancelCompletion();
   group_ = NULL;
 }
 
@@ skipping 179 matching lines @@
     delegate->OnCacheLoaded(cache, id);
     if (cache->owning_group()) {
       scoped_refptr<DatabaseTask> update_task(
           new UpdateGroupLastAccessTimeTask(
               this, cache->owning_group(), base::Time::Now()));
       update_task->Schedule();
     }
     return;
   }
   scoped_refptr<CacheLoadTask> task(GetPendingCacheLoadTask(id));
-  if (task) {
+  if (task.get()) {
     task->AddDelegate(GetOrCreateDelegateReference(delegate));
     return;
   }
   task = new CacheLoadTask(id, this);
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
-  pending_cache_loads_[id] = task;
+  pending_cache_loads_[id] = task.get();
 }
 
 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(
         new UpdateGroupLastAccessTimeTask(
             this, group, base::Time::Now()));
     update_task->Schedule();
     return;
   }
 
   scoped_refptr<GroupLoadTask> task(GetPendingGroupLoadTask(manifest_url));
-  if (task) {
+  if (task.get()) {
     task->AddDelegate(GetOrCreateDelegateReference(delegate));
     return;
   }
 
   if (usage_map_.find(manifest_url.GetOrigin()) == usage_map_.end()) {
     // No need to query the database, return a new group immediately.
     scoped_refptr<AppCacheGroup> group(new AppCacheGroup(
         service_, manifest_url, NewGroupId()));
-    delegate->OnGroupLoaded(group, manifest_url);
+    delegate->OnGroupLoaded(group.get(), 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(
@@ skipping 346 matching lines @@
     int rv = net::OK;
     disk_cache_.reset(new AppCacheDiskCache);
     if (is_incognito_) {
       rv = disk_cache_->InitWithMemBackend(
           kMaxMemDiskCacheSize,
           base::Bind(&AppCacheStorageImpl::OnDiskCacheInitialized,
                      base::Unretained(this)));
     } else {
       rv = disk_cache_->InitWithDiskBackend(
           cache_directory_.Append(kDiskCacheDirectoryName),
-          kMaxDiskCacheSize, false, cache_thread_,
+          kMaxDiskCacheSize, false, cache_thread_.get(),
           base::Bind(&AppCacheStorageImpl::OnDiskCacheInitialized,
                      base::Unretained(this)));
     }
 
     // We should not keep this reference around.
     cache_thread_ = NULL;
 
     if (rv != net::ERR_IO_PENDING)
       OnDiskCacheInitialized(rv);
   }
@@ skipping 13 matching lines @@
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
       db_thread_->PostTask(
           FROM_HERE, base::Bind(base::IgnoreResult(&file_util::Delete),
                                 cache_directory_, true));
     }
   }
 }
 
 }  // namespace appcache