IndexedDB: Remove unnecessary scoped_refptr<T>::get() calls

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 <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 90 matching lines @@
   if (!data_path.empty())
     data_path_ = data_path.Append(kIndexedDBDirectory);
   if (quota_manager_proxy &&
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess)) {
     quota_manager_proxy->RegisterClient(new IndexedDBQuotaClient(this));
   }
 }
 
 IndexedDBFactory* IndexedDBContextImpl::GetIDBFactory() {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
-  if (!idb_factory_.get()) {
+  if (!idb_factory_) {
     // Prime our cache of origins with existing databases so we can
     // detect when dbs are newly created.
     GetOriginSet();
     idb_factory_ = IndexedDBFactory::Create();
   }
-  return idb_factory_.get();
+  return idb_factory_;
 }
 
 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 70 matching lines @@
       IndexedDBConnection* connection = *it;
       connections.erase(it++);
       connection->ForceClose();
     }
     DCHECK_EQ(connections_[origin_url].size(), 0UL);
     connections_.erase(origin_url);
   }
 }
 
 base::FilePath IndexedDBContextImpl::GetFilePath(const GURL& origin_url) {
-  std::string origin_id =
-      webkit_database::GetIdentifierFromOrigin(origin_url);
+  std::string origin_id = webkit_database::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) {
@@ skipping 57 matching lines @@
   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);
 }
 
 quota::QuotaManagerProxy* IndexedDBContextImpl::quota_manager_proxy() {
-  return quota_manager_proxy_.get();
+  return quota_manager_proxy_;
 }
 
 IndexedDBContextImpl::~IndexedDBContextImpl() {
-  if (idb_factory_.get()) {
-    IndexedDBFactory* factory = idb_factory_.get();
+  if (idb_factory_) {
+    IndexedDBFactory* factory = idb_factory_;
     factory->AddRef();
     idb_factory_ = NULL;
     if (!task_runner_->ReleaseSoon(FROM_HERE, factory)) {
       factory->Release();
     }
   }
 
   if (data_path_.empty())
     return;
 
   if (force_keep_session_state_)
     return;
 
   bool has_session_only_databases =
-      special_storage_policy_.get() &&
+      special_storage_policy_ &&
       special_storage_policy_->HasSessionOnlyOrigins();
 
   // Clearning 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_));
 }
 
 base::FilePath IndexedDBContextImpl::GetIndexedDBFilePath(
     const std::string& origin_id) const {
   DCHECK(!data_path_.empty());
-  return data_path_.AppendASCII(origin_id).
-      AddExtension(kIndexedDBExtension).
-      AddExtension(kLevelDBExtension);
+  return data_path_.AppendASCII(origin_id).AddExtension(kIndexedDBExtension)
+      .AddExtension(kLevelDBExtension);
 }
 
 int64 IndexedDBContextImpl::ReadUsageFromDisk(const GURL& origin_url) const {
   if (data_path_.empty())
     return 0;
-  std::string origin_id =
-      webkit_database::GetIdentifierFromOrigin(origin_url);
+  std::string origin_id = webkit_database::GetIdentifierFromOrigin(origin_url);
   base::FilePath file_path = GetIndexedDBFilePath(origin_id);
   return base::ComputeDirectorySize(file_path);
 }
 
 void IndexedDBContextImpl::EnsureDiskUsageCacheInitialized(
     const GURL& origin_url) {
   if (origin_size_map_.find(origin_url) == origin_size_map_.end())
     origin_size_map_[origin_url] = ReadUsageFromDisk(origin_url);
 }
 
@@ skipping 19 matching lines @@
                                             quota::QuotaStatusCode status,
                                             int64 usage,
                                             int64 quota) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(status == quota::kQuotaStatusOk || status == quota::kQuotaErrorAbort)
       << "status was " << status;
   if (status == quota::kQuotaErrorAbort) {
     // We seem to no longer care to wait around for the answer.
     return;
   }
-  TaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&IndexedDBContextImpl::GotUpdatedQuota,
-                 this,
-                 origin_url,
-                 usage,
-                 quota));
+  TaskRunner()->PostTask(FROM_HERE,
+                         base::Bind(&IndexedDBContextImpl::GotUpdatedQuota,
+                                    this,
+                                    origin_url,
+                                    usage,
+                                    quota));
 }
 
 void IndexedDBContextImpl::GotUpdatedQuota(const GURL& origin_url,
                                            int64 usage,
                                            int64 quota) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   space_available_map_[origin_url] = quota - usage;
 }
 
 void IndexedDBContextImpl::QueryAvailableQuota(const GURL& origin_url) {
@@ skipping 35 matching lines @@
   origin_set_.reset();
   origin_size_map_.clear();
   space_available_map_.clear();
 }
 
 base::TaskRunner* IndexedDBContextImpl::TaskRunner() const {
   return task_runner_;
 }
 
 }  // namespace content