Update content/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/browser/loader/redirect_to_file_resource_handler.cc

 // Copyright (c) 2012 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/loader/redirect_to_file_resource_handler.h"
 
 #include "base/bind.h"
 #include "base/files/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
@@ skipping 61 matching lines @@
 
 RedirectToFileResourceHandler::~RedirectToFileResourceHandler() {
 }
 
 bool RedirectToFileResourceHandler::OnResponseStarted(
     int request_id,
     ResourceResponse* response,
     bool* defer) {
   if (response->head.error_code == net::OK ||
       response->head.error_code == net::ERR_IO_PENDING) {
-    DCHECK(deletable_file_ && !deletable_file_->path().empty());
+    DCHECK(deletable_file_.get() && !deletable_file_->path().empty());
     response->head.download_file_path = deletable_file_->path();
   }
   return next_handler_->OnResponseStarted(request_id, response, defer);
 }
 
 bool RedirectToFileResourceHandler::OnWillStart(int request_id,
                                                 const GURL& url,
                                                 bool* defer) {
   request_id_ = request_id;
-  if (!deletable_file_) {
+  if (!deletable_file_.get()) {
     // Defer starting the request until we have created the temporary file.
     // TODO(darin): This is sub-optimal.  We should not delay starting the
     // network request like this.
     did_defer_ = *defer = true;
     base::FileUtilProxy::CreateTemporary(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
         base::PLATFORM_FILE_ASYNC,
         base::Bind(&RedirectToFileResourceHandler::DidCreateTemporaryFile,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
   return next_handler_->OnWillStart(request_id, url, defer);
 }
 
 bool RedirectToFileResourceHandler::OnWillRead(int request_id,
                                                net::IOBuffer** buf,
                                                int* buf_size,
                                                int min_size) {
   DCHECK_EQ(-1, min_size);
 
   if (buf_->capacity() < next_buffer_size_)
     buf_->SetCapacity(next_buffer_size_);
 
   // We should have paused this network request already if the buffer is full.
   DCHECK(!BufIsFull());
 
-  *buf = buf_;
+  *buf = buf_.get();
   *buf_size = buf_->RemainingCapacity();
 
   buf_write_pending_ = true;
   return true;
 }
 
 bool RedirectToFileResourceHandler::OnReadCompleted(int request_id,
                                                     int bytes_read,
                                                     bool* defer) {
   DCHECK(buf_write_pending_);
@@ skipping 94 matching lines @@
     // Note that buf_ is also shared with the code that writes data into the
     // cache, so modifying it can cause some pretty subtle race conditions:
     // https://code.google.com/p/chromium/issues/detail?id=152076
     // We're using DependentIOBuffer instead of DrainableIOBuffer to dodge some
     // of these issues, for the moment.
     // TODO(ncbray) make this code less crazy scary.
     // Also note that Write may increase the refcount of "wrapped" deep in the
     // bowels of its implementation, the use of scoped_refptr here is not
     // spurious.
     scoped_refptr<DependentIOBuffer> wrapped = new DependentIOBuffer(
-        buf_, buf_->StartOfBuffer() + write_cursor_);
+        buf_.get(), buf_->StartOfBuffer() + write_cursor_);
     int write_len = buf_->offset() - write_cursor_;
 
     int rv = file_stream_->Write(
-        wrapped,
+        wrapped.get(),
         write_len,
         base::Bind(&RedirectToFileResourceHandler::DidWriteToFile,
                    base::Unretained(this)));
     if (rv == net::ERR_IO_PENDING) {
       write_callback_pending_ = true;
       return true;
     }
     if (rv <= 0)
       return false;
     next_handler_->OnDataDownloaded(request_id_, rv);
@@ skipping 10 matching lines @@
 }
 
 void RedirectToFileResourceHandler::ResumeIfDeferred() {
   if (did_defer_) {
     did_defer_ = false;
     controller()->Resume();
   }
 }
 
 }  // namespace content