Remove implicit conversions from scoped_refptr to T* in chrome/browser/media_galleries/

chrome/browser/media_galleries/fileapi/readahead_file_stream_reader.cc

 // Copyright 2014 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 "chrome/browser/media_galleries/fileapi/readahead_file_stream_reader.h"
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 20 matching lines @@
 
 int ReadaheadFileStreamReader::Read(
     net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) {
   DCHECK(!pending_sink_buffer_.get());
   DCHECK(pending_read_callback_.is_null());
 
   ReadFromSourceIfNeeded();
 
   scoped_refptr<net::DrainableIOBuffer> sink =
       new net::DrainableIOBuffer(buf, buf_len);
-  int result = FinishReadFromCacheOrStoredError(sink);
+  int result = FinishReadFromCacheOrStoredError(sink.get());
 
   // We are waiting for an source read to complete, so save the request.
   if (result == net::ERR_IO_PENDING) {
     DCHECK(!pending_sink_buffer_.get());
     DCHECK(pending_read_callback_.is_null());
     pending_sink_buffer_ = sink;
     pending_read_callback_ = callback;
   }
 
   return result;
@@ skipping 44 matching lines @@
 void ReadaheadFileStreamReader::ReadFromSourceIfNeeded() {
   if (!source_.get() || source_has_pending_read_ ||
       buffers_.size() >= kDesiredNumberOfBuffers) {
     return;
   }
 
   source_has_pending_read_ = true;
 
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kBufferSize));
   int result = source_->Read(
-      buf,
+      buf.get(),
       kBufferSize,
       base::Bind(&ReadaheadFileStreamReader::OnFinishReadFromSource,
-                 weak_factory_.GetWeakPtr(), buf));
+                 weak_factory_.GetWeakPtr(),
+                 buf));
 
   if (result != net::ERR_IO_PENDING)
-    OnFinishReadFromSource(buf, result);
+    OnFinishReadFromSource(buf.get(), result);
 }
 
 void ReadaheadFileStreamReader::OnFinishReadFromSource(net::IOBuffer* buf,
                                                        int result) {
   DCHECK(result != net::ERR_IO_PENDING);
   DCHECK(source_has_pending_read_);
   source_has_pending_read_ = false;
 
   // Either store the data read from |source_|, or store the error code.
   if (result > 0) {
@@ skipping 11 matching lines @@
   if (pending_sink_buffer_.get()) {
     DCHECK(!pending_read_callback_.is_null());
 
     // Free the pending callback before running it, as the callback often
     // dispatches another read.
     scoped_refptr<net::DrainableIOBuffer> sink = pending_sink_buffer_;
     pending_sink_buffer_ = NULL;
     net::CompletionCallback completion_callback = pending_read_callback_;
     pending_read_callback_.Reset();
 
-    completion_callback.Run(FinishReadFromCacheOrStoredError(sink));
+    completion_callback.Run(FinishReadFromCacheOrStoredError(sink.get()));
   }
 }