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

content/browser/indexed_db/indexed_db_context_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/indexed_db/indexed_db_context_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 101 matching lines @@
   IDB_TRACE("init");
   if (!data_path.empty())
     data_path_ = data_path.Append(kIndexedDBDirectory);
   if (quota_manager_proxy) {
     quota_manager_proxy->RegisterClient(new IndexedDBQuotaClient(this));
   }
 }
 
 IndexedDBFactory* IndexedDBContextImpl::GetIDBFactory() {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
-  if (!factory_) {
+  if (!factory_.get()) {
     // Prime our cache of origins with existing databases so we can
     // detect when dbs are newly created.
     GetOriginSet();
     factory_ = new IndexedDBFactoryImpl(this);
   }
-  return factory_;
+  return factory_.get();
 }
 
 std::vector<GURL> IndexedDBContextImpl::GetAllOrigins() {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   std::vector<GURL> origins;
   std::set<GURL>* origins_set = GetOriginSet();
   for (std::set<GURL>::const_iterator iter = origins_set->begin();
        iter != origins_set->end();
        ++iter) {
     origins.push_back(*iter);
@@ skipping 43 matching lines @@
     info->SetDouble("last_modified",
                     GetOriginLastModified(origin_url).ToJsTime());
     if (!is_incognito())
       info->SetString("path", GetFilePath(origin_url).value());
     info->SetDouble("connection_count", GetConnectionCount(origin_url));
 
     // This ends up being O(n^2) since we iterate over all open databases
     // to extract just those in the origin, and we're iterating over all
     // origins in the outer loop.
 
-    if (factory_) {
+    if (factory_.get()) {
       std::pair<IndexedDBFactory::OriginDBMapIterator,
                 IndexedDBFactory::OriginDBMapIterator> range =
           factory_->GetOpenDatabasesForOrigin(origin_url);
       // TODO(jsbell): Sort by name?
       scoped_ptr<base::ListValue> database_list(new base::ListValue());
 
       for (IndexedDBFactory::OriginDBMapIterator it = range.first;
            it != range.second;
            ++it) {
         const IndexedDBDatabase* db = it->second;
@@ skipping 136 matching lines @@
 void IndexedDBContextImpl::ForceClose(const GURL origin_url,
                                       ForceCloseReason reason) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   UMA_HISTOGRAM_ENUMERATION("WebCore.IndexedDB.Context.ForceCloseReason",
                             reason,
                             FORCE_CLOSE_REASON_MAX);
 
   if (data_path_.empty() || !IsInOriginSet(origin_url))
     return;
 
-  if (factory_)
+  if (factory_.get())
     factory_->ForceClose(origin_url);
   DCHECK_EQ(0UL, GetConnectionCount(origin_url));
 }
 
 size_t IndexedDBContextImpl::GetConnectionCount(const GURL& origin_url) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   if (data_path_.empty() || !IsInOriginSet(origin_url))
     return 0;
 
-  if (!factory_)
+  if (!factory_.get())
     return 0;
 
   return factory_->GetConnectionCount(origin_url);
 }
 
 base::FilePath IndexedDBContextImpl::GetFilePath(const GURL& origin_url) const {
   std::string origin_id = storage::GetIdentifierFromOrigin(origin_url);
   return GetIndexedDBFilePath(origin_id);
 }
 
 base::FilePath IndexedDBContextImpl::GetFilePathForTesting(
     const std::string& origin_id) const {
   return GetIndexedDBFilePath(origin_id);
 }
 
 void IndexedDBContextImpl::SetTaskRunnerForTesting(
     base::SequencedTaskRunner* task_runner) {
-  DCHECK(!task_runner_);
+  DCHECK(!task_runner_.get());
   task_runner_ = task_runner;
 }
 
 void IndexedDBContextImpl::ConnectionOpened(const GURL& origin_url,
                                             IndexedDBConnection* connection) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   if (quota_manager_proxy()) {
     quota_manager_proxy()->NotifyStorageAccessed(
         storage::QuotaClient::kIndexedDatabase,
         origin_url,
@@ skipping 10 matching lines @@
 
 void IndexedDBContextImpl::ConnectionClosed(const GURL& origin_url,
                                             IndexedDBConnection* connection) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   if (quota_manager_proxy()) {
     quota_manager_proxy()->NotifyStorageAccessed(
         storage::QuotaClient::kIndexedDatabase,
         origin_url,
         storage::kStorageTypeTemporary);
   }
-  if (factory_ && factory_->GetConnectionCount(origin_url) == 0)
+  if (factory_.get() && factory_->GetConnectionCount(origin_url) == 0)
     QueryDiskAndUpdateQuotaUsage(origin_url);
 }
 
 void IndexedDBContextImpl::TransactionComplete(const GURL& origin_url) {
-  DCHECK(!factory_ || factory_->GetConnectionCount(origin_url) > 0);
+  DCHECK(!factory_.get() || factory_->GetConnectionCount(origin_url) > 0);
   QueryDiskAndUpdateQuotaUsage(origin_url);
   QueryAvailableQuota(origin_url);
 }
 
 void IndexedDBContextImpl::DatabaseDeleted(const GURL& origin_url) {
   AddToOriginSet(origin_url);
   QueryDiskAndUpdateQuotaUsage(origin_url);
   QueryAvailableQuota(origin_url);
 }
 
 bool IndexedDBContextImpl::WouldBeOverQuota(const GURL& origin_url,
                                             int64 additional_bytes) {
   if (space_available_map_.find(origin_url) == space_available_map_.end()) {
     // We haven't heard back from the QuotaManager yet, just let it through.
     return false;
   }
   bool over_quota = additional_bytes > space_available_map_[origin_url];
   return over_quota;
 }
 
 bool IndexedDBContextImpl::IsOverQuota(const GURL& origin_url) {
   const int kOneAdditionalByte = 1;
   return WouldBeOverQuota(origin_url, kOneAdditionalByte);
 }
 
 storage::QuotaManagerProxy* IndexedDBContextImpl::quota_manager_proxy() {
-  return quota_manager_proxy_;
+  return quota_manager_proxy_.get();
 }
 
 IndexedDBContextImpl::~IndexedDBContextImpl() {
-  if (factory_) {
+  if (factory_.get()) {
     TaskRunner()->PostTask(
         FROM_HERE, base::Bind(&IndexedDBFactory::ContextDestroyed, factory_));
     factory_ = NULL;
   }
 
   if (data_path_.empty())
     return;
 
   if (force_keep_session_state_)
     return;
 
   bool has_session_only_databases =
-      special_storage_policy_ &&
+      special_storage_policy_.get() &&
       special_storage_policy_->HasSessionOnlyOrigins();
 
   // Clearing only session-only databases, and there are none.
   if (!has_session_only_databases)
     return;
 
   TaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &ClearSessionOnlyOrigins, data_path_, special_storage_policy_));
@@ skipping 99 matching lines @@
   return origin_set_.get();
 }
 
 void IndexedDBContextImpl::ResetCaches() {
   origin_set_.reset();
   origin_size_map_.clear();
   space_available_map_.clear();
 }
 
 base::SequencedTaskRunner* IndexedDBContextImpl::TaskRunner() const {
-  return task_runner_;
+  return task_runner_.get();
 }
 
 }  // namespace content