Remove implicit conversions from scoped_refptr to T* in content/browser/appcache/

content/browser/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 "content/browser/appcache/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 64 matching lines @@
     AppCacheDatabase* database,
     scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy,
     bool force_keep_session_state) {
   scoped_ptr<AppCacheDatabase> database_to_delete(database);
 
   // If saving session state, only delete the database.
   if (force_keep_session_state)
     return;
 
   bool has_session_only_appcaches =
-      special_storage_policy &&
+      special_storage_policy.get() &&
       special_storage_policy->HasSessionOnlyOrigins();
 
   // Clearning only session-only databases, and there are none.
   if (!has_session_only_appcaches)
     return;
 
   std::set<GURL> origins;
   database->FindOriginsWithGroups(&origins);
   if (origins.empty())
     return;  // nothing to delete
 
   sql::Connection* connection = database->db_connection();
   if (!connection) {
     NOTREACHED() << "Missing database connection.";
     return;
   }
 
   std::set<GURL>::const_iterator origin;
-  DCHECK(special_storage_policy);
+  DCHECK(special_storage_policy.get());
   for (origin = origins.begin(); origin != origins.end(); ++origin) {
     if (!special_storage_policy->IsStorageSessionOnly(*origin))
       continue;
     if (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) {
@@ skipping 1229 matching lines @@
                      service()->force_keep_session_state()))) {
     delete database_;
   }
   database_ = NULL;  // So no further database tasks can be scheduled.
 }
 
 void AppCacheStorageImpl::Initialize(
     const base::FilePath& cache_directory,
     const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread) {
-  DCHECK(db_thread);
+  DCHECK(db_thread.get());
 
   cache_directory_ = cache_directory;
   is_incognito_ = cache_directory_.empty();
 
   base::FilePath db_file_path;
   if (!is_incognito_)
     db_file_path = cache_directory_.Append(kAppCacheDatabaseName);
   database_ = new AppCacheDatabase(db_file_path);
 
   db_thread_ = db_thread;
@@ skipping 492 matching lines @@
       base::Bind(&AppCacheStorageImpl::CallScheduleReinitialize,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AppCacheStorageImpl::CallScheduleReinitialize() {
   service_->ScheduleReinitialize();
   // note: 'this' may be deleted at this point.
 }
 
 }  // namespace content