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

content/browser/indexed_db/indexed_db_backing_store.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_backing_store.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
@@ skipping 1052 matching lines @@
   scoped_refptr<IndexedDBBackingStore> backing_store =
       Create(indexed_db_factory,
              origin_url,
              blob_path,
              request_context,
              db.Pass(),
              comparator.Pass(),
              task_runner,
              status);
 
-  if (clean_journal && backing_store &&
+  if (clean_journal && backing_store.get() &&
       !backing_store->CleanUpBlobJournal(LiveBlobJournalKey::Encode()).ok()) {
     HistogramOpenStatus(
         INDEXED_DB_BACKING_STORE_OPEN_FAILED_CLEANUP_JOURNAL_ERROR, origin_url);
     return scoped_refptr<IndexedDBBackingStore>();
   }
   return backing_store;
 }
 
 // static
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::OpenInMemory(
@@ skipping 1162 matching lines @@
     aborted_ = true;
   }
 
  private:
   virtual ~ChainedBlobWriterImpl() {}
 
   void WriteNextFile() {
     DCHECK(!waiting_for_callback_);
     DCHECK(!aborted_);
     if (iter_ == blobs_.end()) {
-      DCHECK(!self_ref_);
+      DCHECK(!self_ref_.get());
       callback_->Run(true);
       return;
     } else {
       if (!backing_store_->WriteBlobFile(database_id_, *iter_, this)) {
         callback_->Run(false);
         return;
       }
       waiting_for_callback_ = true;
     }
   }
@@ skipping 42 matching lines @@
                    write_status == FileWriterDelegate::SUCCESS_COMPLETED,
                    bytes_written_));
   }
 
   void writeBlobToFileOnIOThread(const FilePath& file_path,
                                  const GURL& blob_url,
                                  net::URLRequestContext* request_context) {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
     scoped_ptr<storage::FileStreamWriter> writer(
         storage::FileStreamWriter::CreateForLocalFile(
-            task_runner_,
+            task_runner_.get(),
             file_path,
             0,
             storage::FileStreamWriter::CREATE_NEW_FILE));
     scoped_ptr<FileWriterDelegate> delegate(
         new FileWriterDelegate(writer.Pass(),
                                FileWriterDelegate::FLUSH_ON_COMPLETION));
 
     DCHECK(blob_url.is_valid());
     scoped_ptr<net::URLRequest> blob_request(request_context->CreateRequest(
         blob_url, net::DEFAULT_PRIORITY, delegate.get(), NULL));
@@ skipping 59 matching lines @@
 
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Transaction::ChainedBlobWriter::ReportWriteCompletion,
                    chained_blob_writer,
                    true,
                    info.size));
   } else {
     DCHECK(descriptor.url().is_valid());
     scoped_refptr<LocalWriteClosure> write_closure(
-        new LocalWriteClosure(chained_blob_writer, task_runner_));
+        new LocalWriteClosure(chained_blob_writer, task_runner_.get()));
     content::BrowserThread::PostTask(
         content::BrowserThread::IO,
         FROM_HERE,
         base::Bind(&LocalWriteClosure::writeBlobToFileOnIOThread,
                    write_closure.get(),
                    path,
                    descriptor.url(),
                    request_context_));
   }
   return true;
@@ skipping 641 matching lines @@
       DCHECK(iterator_->IsValid());
     }
   }
 }
 
 IndexedDBBackingStore::Cursor::Cursor(
     scoped_refptr<IndexedDBBackingStore> backing_store,
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     const CursorOptions& cursor_options)
-    : backing_store_(backing_store),
+    : backing_store_(backing_store.get()),
       transaction_(transaction),
       database_id_(database_id),
       cursor_options_(cursor_options) {
 }
 IndexedDBBackingStore::Cursor::~Cursor() {}
 
 bool IndexedDBBackingStore::Cursor::FirstSeek(leveldb::Status* s) {
   iterator_ = transaction_->transaction()->CreateIterator();
   if (cursor_options_.forward)
     *s = iterator_->Seek(cursor_options_.low_key);
@@ skipping 964 matching lines @@
   if (!s.ok())
     return s;
   // To signal how many blobs need attention right now.
   blobs_to_remove_.swap(primary_journal);
   return leveldb::Status::OK();
 }
 
 leveldb::Status IndexedDBBackingStore::Transaction::CommitPhaseOne(
     scoped_refptr<BlobWriteCallback> callback) {
   IDB_TRACE("IndexedDBBackingStore::Transaction::CommitPhaseOne");
-  DCHECK(transaction_);
+  DCHECK(transaction_.get());
   DCHECK(backing_store_->task_runner()->RunsTasksOnCurrentThread());
 
   leveldb::Status s;
 
   s = backing_store_->CleanUpBlobJournal(BlobJournalKey::Encode());
   if (!s.ok()) {
     INTERNAL_WRITE_ERROR(TRANSACTION_COMMIT_METHOD);
     transaction_ = NULL;
     return s;
   }
@@ skipping 112 matching lines @@
   // Creating the writer will start it going asynchronously.
   chained_blob_writer_ =
       new ChainedBlobWriterImpl(database_id_,
                                 backing_store_,
                                 new_files_to_write,
                                 new BlobWriteCallbackWrapper(this, callback));
 }
 
 void IndexedDBBackingStore::Transaction::Rollback() {
   IDB_TRACE("IndexedDBBackingStore::Transaction::Rollback");
-  if (chained_blob_writer_) {
+  if (chained_blob_writer_.get()) {
     chained_blob_writer_->Abort();
     chained_blob_writer_ = NULL;
   }
   if (transaction_.get() == NULL)
     return;
   transaction_->Rollback();
   transaction_ = NULL;
 }
 
 IndexedDBBackingStore::BlobChangeRecord::BlobChangeRecord(
@@ skipping 104 matching lines @@
     int64_t size,
     base::Time last_modified)
     : is_file_(true),
       file_path_(file_path),
       key_(key),
       size_(size),
       last_modified_(last_modified) {
 }
 
 }  // namespace content