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

content/browser/indexed_db/indexed_db_database.cc

 // Copyright (c) 2013 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_database.h"
 
 #include <math.h>
 #include <vector>
 
 #include "base/auto_reset.h"
@@ skipping 1014 matching lines @@
           IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionConstraintError,
                                  "Key already exists in the object store."));
       return;
     }
   }
 
   ScopedVector<IndexWriter> index_writers;
   string16 error_message;
   bool obeys_constraints = false;
   bool backing_store_success = MakeIndexWriters(transaction,
-                                                backing_store_.get(),
+                                                backing_store_,
                                                 database_id_,
                                                 object_store_,
                                                 *key,
                                                 key_was_generated,
                                                 index_ids_,
                                                 index_keys_,
                                                 &index_writers,
                                                 &error_message,
                                                 &obeys_constraints);
   if (!backing_store_success) {
@@ skipping 20 matching lines @@
   if (!backing_store_success) {
     callbacks_->OnError(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error performing put/add."));
     return;
   }
 
   for (size_t i = 0; i < index_writers.size(); ++i) {
     IndexWriter* index_writer = index_writers[i];
     index_writer->WriteIndexKeys(record_identifier,
-                                 backing_store_.get(),
+                                 backing_store_,
                                  transaction->BackingStoreTransaction(),
                                  database_id_,
                                  object_store_.id);
   }
 
   if (object_store_.auto_increment &&
       put_mode_ != IndexedDBDatabase::CURSOR_UPDATE &&
       key->type() == WebIDBKey::NumberType) {
     bool ok = UpdateKeyGenerator(backing_store_,
                                  transaction,
@@ skipping 51 matching lines @@
   }
 
   ScopedVector<IndexWriter> index_writers;
   string16 error_message;
   bool obeys_constraints = false;
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   const IndexedDBObjectStoreMetadata& object_store_metadata =
       metadata_.object_stores[object_store_id];
   bool backing_store_success = MakeIndexWriters(transaction,
-                                                store.get(),
+                                                store,
                                                 id(),
                                                 object_store_metadata,
                                                 *primary_key,
                                                 false,
                                                 index_ids,
                                                 index_keys,
                                                 &index_writers,
                                                 &error_message,
                                                 &obeys_constraints);
   if (!backing_store_success) {
     transaction->Abort(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error updating index keys."));
     return;
   }
   if (!obeys_constraints) {
     transaction->Abort(IndexedDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionConstraintError, error_message));
     return;
   }
 
   for (size_t i = 0; i < index_writers.size(); ++i) {
     IndexWriter* index_writer = index_writers[i];
     index_writer->WriteIndexKeys(record_identifier,
-                                 store.get(),
+                                 store,
                                  transaction->BackingStoreTransaction(),
                                  id(),
                                  object_store_id);
   }
 }
 
 void IndexedDBDatabase::SetIndexesReady(int64 transaction_id,
                                         int64,
                                         const std::vector<int64>& index_ids) {
   IDB_TRACE("IndexedDBDatabase::SetIndexesReady");
@@ skipping 378 matching lines @@
   DCHECK(connections_.has(connection));
 
   scoped_refptr<IndexedDBTransaction> transaction =
       IndexedDBTransaction::Create(
           transaction_id,
           connection->callbacks(),
           object_store_ids,
           static_cast<indexed_db::TransactionMode>(mode),
           this);
   DCHECK(transactions_.find(transaction_id) == transactions_.end());
-  transactions_[transaction_id] = transaction.get();
+  transactions_[transaction_id] = transaction;
 }
 
 bool IndexedDBDatabase::IsOpenConnectionBlocked() const {
   return !pending_delete_calls_.empty() ||
          running_version_change_transaction_ ||
          pending_run_version_change_transaction_call_;
 }
 
 void IndexedDBDatabase::OpenConnection(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int64 transaction_id,
     int64 version) {
   const WebKit::WebIDBCallbacks::DataLoss kDataLoss =
       WebKit::WebIDBCallbacks::DataLossNone;
   OpenConnection(
       callbacks, database_callbacks, transaction_id, version, kDataLoss);
 }
 
 void IndexedDBDatabase::OpenConnection(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int64 transaction_id,
     int64 version,
     WebKit::WebIDBCallbacks::DataLoss data_loss) {
-  DCHECK(backing_store_.get());
+  DCHECK(backing_store_);
 
   // TODO(jsbell): Should have a priority queue so that higher version
   // requests are processed first. http://crbug.com/225850
   if (IsOpenConnectionBlocked()) {
     // The backing store only detects data loss when it is first opened. The
     // presence of existing connections means we didn't even check for data loss
     // so there'd better not be any.
     DCHECK_NE(WebKit::WebIDBCallbacks::DataLossTotal, data_loss);
     pending_open_calls_.push_back(new PendingOpenCall(
         callbacks, database_callbacks, transaction_id, version));
@@ skipping 70 matching lines @@
   callbacks->OnSuccess(connection.Pass(), this->metadata());
 }
 
 void IndexedDBDatabase::RunVersionChangeTransaction(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_ptr<IndexedDBConnection> connection,
     int64 transaction_id,
     int64 requested_version,
     WebKit::WebIDBCallbacks::DataLoss data_loss) {
 
-  DCHECK(callbacks.get());
+  DCHECK(callbacks);
   DCHECK(connections_.has(connection.get()));
   if (ConnectionCount() > 1) {
     DCHECK_NE(WebKit::WebIDBCallbacks::DataLossTotal, data_loss);
     // Front end ensures the event is not fired at connections that have
     // close_pending set.
     for (ConnectionSet::const_iterator it = connections_.begin();
          it != connections_.end();
          ++it) {
       if (*it != connection.get()) {
         (*it)->callbacks()->OnVersionChange(
@@ skipping 81 matching lines @@
   DeleteDatabaseFinal(callbacks);
 }
 
 bool IndexedDBDatabase::IsDeleteDatabaseBlocked() const {
   return !!ConnectionCount();
 }
 
 void IndexedDBDatabase::DeleteDatabaseFinal(
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(!IsDeleteDatabaseBlocked());
-  DCHECK(backing_store_.get());
+  DCHECK(backing_store_);
   if (!backing_store_->DeleteDatabase(metadata_.name)) {
     callbacks->OnError(
         IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
                                "Internal error deleting database."));
     return;
   }
   metadata_.version = kNoStringVersion;
   metadata_.id = kInvalidId;
   metadata_.int_version = IndexedDBDatabaseMetadata::NO_INT_VERSION;
   metadata_.object_stores.clear();
@@ skipping 42 matching lines @@
 
   // TODO(jsbell): Add a test for the pending_open_calls_ cases below.
   if (!ConnectionCount() && !pending_open_calls_.size() &&
       !pending_delete_calls_.size()) {
     DCHECK(transactions_.empty());
 
     backing_store_ = NULL;
 
     // factory_ should only be null in unit tests.
     // TODO(jsbell): DCHECK(factory_ || !in_unit_tests) - somehow.
-    if (factory_.get())
+    if (factory_)
       factory_->RemoveIDBDatabaseBackend(identifier_);
   }
 }
 
 void CreateObjectStoreAbortOperation::Perform(
     IndexedDBTransaction* transaction) {
   IDB_TRACE("CreateObjectStoreAbortOperation");
   DCHECK(!transaction);
   database_->RemoveObjectStore(object_store_id_);
 }
 
 void DeleteObjectStoreAbortOperation::Perform(
     IndexedDBTransaction* transaction) {
   IDB_TRACE("DeleteObjectStoreAbortOperation");
   DCHECK(!transaction);
   database_->AddObjectStore(object_store_metadata_,
                             IndexedDBObjectStoreMetadata::kInvalidId);
 }
 
 void IndexedDBDatabase::VersionChangeAbortOperation::Perform(
     IndexedDBTransaction* transaction) {
   IDB_TRACE("VersionChangeAbortOperation");
   DCHECK(!transaction);
   database_->metadata_.version = previous_version_;
   database_->metadata_.int_version = previous_int_version_;
 }
 
 }  // namespace content