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

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 <set>
 
 #include "base/auto_reset.h"
@@ skipping 922 matching lines @@
   }
 
   ScopedVector<IndexWriter> index_writers;
   base::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,
-                                                backing_store_,
+                                                backing_store_.get(),
                                                 id(),
                                                 object_store_metadata,
                                                 *primary_key,
                                                 false,
                                                 index_keys,
                                                 &index_writers,
                                                 &error_message,
                                                 &obeys_constraints);
   if (!backing_store_success) {
     transaction->Abort(IndexedDBDatabaseError(
         blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error updating index keys."));
     return;
   }
   if (!obeys_constraints) {
     transaction->Abort(IndexedDBDatabaseError(
         blink::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,
-                                 backing_store_,
+                                 backing_store_.get(),
                                  transaction->BackingStoreTransaction(),
                                  id(),
                                  object_store_id);
   }
 }
 
 void IndexedDBDatabase::SetIndexesReady(int64 transaction_id,
                                         int64,
                                         const std::vector<int64>& index_ids) {
   IDB_TRACE1("IndexedDBDatabase::SetIndexesReady", "txn.id", transaction_id);
@@ skipping 489 matching lines @@
     return;
 
   // The transaction will add itself to this database's coordinator, which
   // manages the lifetime of the object.
   TransactionCreated(new IndexedDBTransaction(
       transaction_id,
       connection->callbacks(),
       std::set<int64>(object_store_ids.begin(), object_store_ids.end()),
       mode,
       this,
-      new IndexedDBBackingStore::Transaction(backing_store_)));
+      new IndexedDBBackingStore::Transaction(backing_store_.get())));
 }
 
 void IndexedDBDatabase::TransactionCreated(IndexedDBTransaction* transaction) {
   transactions_[transaction->id()] = transaction;
 }
 
 bool IndexedDBDatabase::IsOpenConnectionBlocked() const {
   return !pending_delete_calls_.empty() ||
          transaction_coordinator_.IsRunningVersionChangeTransaction() ||
          pending_run_version_change_transaction_call_;
 }
 
 void IndexedDBDatabase::OpenConnection(
     const IndexedDBPendingConnection& connection) {
-  DCHECK(backing_store_);
+  DCHECK(backing_store_.get());
 
   // 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(blink::WebIDBDataLossTotal, connection.callbacks->data_loss());
     pending_open_calls_.push_back(connection);
     return;
@@ skipping 76 matching lines @@
       CreateConnection(connection.database_callbacks,
                        connection.child_process_id),
       this->metadata());
 }
 
 void IndexedDBDatabase::RunVersionChangeTransaction(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_ptr<IndexedDBConnection> connection,
     int64 transaction_id,
     int64 requested_version) {
-
-  DCHECK(callbacks);
+  DCHECK(callbacks.get());
   DCHECK(connections_.count(connection.get()));
   if (ConnectionCount() > 1) {
     DCHECK_NE(blink::WebIDBDataLossTotal, callbacks->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(metadata_.int_version,
@@ skipping 54 matching lines @@
   DeleteDatabaseFinal(callbacks);
 }
 
 bool IndexedDBDatabase::IsDeleteDatabaseBlocked() const {
   return !!ConnectionCount();
 }
 
 void IndexedDBDatabase::DeleteDatabaseFinal(
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(!IsDeleteDatabaseBlocked());
-  DCHECK(backing_store_);
+  DCHECK(backing_store_.get());
   leveldb::Status s = backing_store_->DeleteDatabase(metadata_.name);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error deleting database.");
     callbacks->OnError(error);
     if (s.IsCorruption()) {
       GURL origin_url = backing_store_->origin_url();
       backing_store_ = NULL;
       factory_->HandleBackingStoreCorruption(origin_url, error);
     }
@@ skipping 105 matching lines @@
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE1("IndexedDBDatabase::VersionChangeAbortOperation",
              "txn.id",
              transaction->id());
   metadata_.version = previous_version;
   metadata_.int_version = previous_int_version;
 }
 
 }  // namespace content