Call scoped_refptr<T>::get() rather than relying on implicit "operator T*"

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 1002 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) {
     IndexedDBObjectStoreImpl::IndexWriter* index_writer = index_writers[i];
     index_writer->WriteIndexKeys(record_identifier,
-                                 backing_store_,
+                                 backing_store_.get(),
                                  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 479 matching lines @@
   DCHECK(database_callbacks_set_.has(callbacks));
 
   scoped_refptr<IndexedDBTransaction> transaction =
       IndexedDBTransaction::Create(
           transaction_id,
           callbacks,
           object_store_ids,
           static_cast<indexed_db::TransactionMode>(mode),
           this);
   DCHECK(transactions_.find(transaction_id) == transactions_.end());
-  transactions_[transaction_id] = transaction;
+  transactions_[transaction_id] = transaction.get();
 }
 
 bool IndexedDBDatabase::IsOpenConnectionBlocked() const {
   return !pending_delete_calls_.empty() ||
          running_version_change_transaction_ ||
          pending_run_version_change_transaction_call_;
 }
 
 void IndexedDBDatabase::OpenConnection(
     scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
@@ skipping 76 matching lines @@
   database_callbacks_set_.insert(database_callbacks);
   callbacks->OnSuccess(this, this->metadata());
 }
 
 void IndexedDBDatabase::RunVersionChangeTransaction(
     scoped_refptr<IndexedDBCallbacksWrapper> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacksWrapper> database_callbacks,
     int64 transaction_id,
     int64 requested_version) {
 
-  DCHECK(callbacks);
+  DCHECK(callbacks.get());
   DCHECK(database_callbacks_set_.has(database_callbacks));
   if (ConnectionCount() > 1) {
     // Front end ensures the event is not fired at connections that have
     // close_pending set.
     for (DatabaseCallbacksSet::const_iterator it =
              database_callbacks_set_.begin();
          it != database_callbacks_set_.end();
          ++it) {
-      if (*it != database_callbacks.get())
+      if (it->get() != database_callbacks.get())
         (*it)->OnVersionChange(metadata_.int_version, requested_version);
     }
     // TODO(jsbell): Remove the call to on_blocked and instead wait
     // until the frontend tells us that all the "versionchange" events
     // have been delivered.  http://crbug.com/100123
     callbacks->OnBlocked(metadata_.int_version);
 
     DCHECK(!pending_run_version_change_transaction_call_);
     pending_run_version_change_transaction_call_.reset(new PendingOpenCall(
         callbacks, database_callbacks, transaction_id, requested_version));
@@ skipping 52 matching lines @@
   DeleteDatabaseFinal(callbacks);
 }
 
 bool IndexedDBDatabase::IsDeleteDatabaseBlocked() const {
   return !!ConnectionCount();
 }
 
 void IndexedDBDatabase::DeleteDatabaseFinal(
     scoped_refptr<IndexedDBCallbacksWrapper> callbacks) {
   DCHECK(!IsDeleteDatabaseBlocked());
-  DCHECK(backing_store_);
+  DCHECK(backing_store_.get());
   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();
   callbacks->OnSuccess();
 }
 
 void IndexedDBDatabase::Close(
     scoped_refptr<IndexedDBDatabaseCallbacksWrapper> callbacks) {
-  DCHECK(callbacks);
+  DCHECK(callbacks.get());
   DCHECK(database_callbacks_set_.has(callbacks));
 
   // Close outstanding transactions from the closing connection. This
   // can not happen if the close is requested by the connection itself
   // as the front-end defers the close until all transactions are
   // complete, so something unusual has happened e.g. unexpected
   // process termination.
   {
     TransactionMap transactions(transactions_);
     for (TransactionMap::const_iterator it = transactions.begin(),
                                         end = transactions.end();
          it != end;
          ++it) {
-      if (it->second->connection() == callbacks)
+      if (it->second->connection() == callbacks.get())
         it->second->Abort(
             IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
                                    "Connection is closing."));
     }
   }
 
   database_callbacks_set_.erase(callbacks);
   if (pending_second_half_open_ &&
-      pending_second_half_open_->DatabaseCallbacks() == callbacks) {
+      pending_second_half_open_->DatabaseCallbacks().get() == callbacks.get()) {
     pending_second_half_open_->Callbacks()->OnError(
         IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionAbortError,
                                "The connection was closed."));
     pending_second_half_open_.reset();
   }
 
   // process_pending_calls allows the inspector to process a pending open call
   // and call close, reentering IndexedDBDatabase::close. Then the
   // backend would be removed both by the inspector closing its connection, and
   // by the connection that first called close.
   // To avoid that situation, don't proceed in case of reentrancy.
   if (closing_connection_)
     return;
   base::AutoReset<bool> ClosingConnection(&closing_connection_, true);
   ProcessPendingCalls();
 
   // 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;
 
     // This check should only be false in unit tests.
     // TODO(jsbell): Assert factory_ || we're executing a unit test.
-    if (factory_)
+    if (factory_.get())
       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