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

content/browser/download/download_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/download/download_resource_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 174 matching lines @@
     int status = headers->response_code();
     if (2 == status / 100  && status != net::HTTP_PARTIAL_CONTENT) {
       // Success & not range response; if we asked for a range, we didn't
       // get it--reset the file pointers to reflect that.
       save_info_->offset = 0;
       save_info_->hash_state = "";
     }
   }
 
   std::string content_type_header;
-  if (!response->head.headers ||
+  if (!response->head.headers.get() ||
       !response->head.headers->GetMimeType(&content_type_header))
     content_type_header = "";
   info->original_mime_type = content_type_header;
 
-  if (!response->head.headers ||
+  if (!response->head.headers.get() ||
       !response->head.headers->EnumerateHeader(
           NULL, "Accept-Ranges", &accept_ranges_)) {
     accept_ranges_ = "";
   }
 
   info->save_info = save_info_.Pass();
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&StartOnUIThread,
@@ skipping 25 matching lines @@
                                           bool* defer) {
   return true;
 }
 
 // Create a new buffer, which will be handed to the download thread for file
 // writing and deletion.
 bool DownloadResourceHandler::OnWillRead(int request_id, net::IOBuffer** buf,
                                          int* buf_size, int min_size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(buf && buf_size);
-  DCHECK(!read_buffer_);
+  DCHECK(!read_buffer_.get());
 
   *buf_size = min_size < 0 ? kReadBufSize : min_size;
   last_buffer_size_ = *buf_size;
   read_buffer_ = new net::IOBuffer(*buf_size);
   *buf = read_buffer_.get();
   return true;
 }
 
 // Pass the buffer to the download file writer.
 bool DownloadResourceHandler::OnReadCompleted(int request_id, int bytes_read,
                                               bool* defer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(read_buffer_);
+  DCHECK(read_buffer_.get());
 
   base::TimeTicks now(base::TimeTicks::Now());
   if (!last_read_time_.is_null()) {
     double seconds_since_last_read = (now - last_read_time_).InSecondsF();
     if (now == last_read_time_)
       // Use 1/10 ms as a "very small number" so that we avoid
       // divide-by-zero error and still record a very high potential bandwidth.
       seconds_since_last_read = 0.00001;
 
     double actual_bandwidth = (bytes_read)/seconds_since_last_read;
     double potential_bandwidth = last_buffer_size_/seconds_since_last_read;
     RecordBandwidth(actual_bandwidth, potential_bandwidth);
   }
   last_read_time_ = now;
 
   if (!bytes_read)
     return true;
   bytes_read_ += bytes_read;
-  DCHECK(read_buffer_);
+  DCHECK(read_buffer_.get());
 
   // Take the data ship it down the stream.  If the stream is full, pause the
   // request; the stream callback will resume it.
   if (!stream_writer_->Write(read_buffer_, bytes_read)) {
     PauseRequest();
     *defer = was_deferred_ = true;
     last_stream_pause_time_ = now;
   }
 
   read_buffer_ = NULL;  // Drop our reference.
@@ skipping 196 matching lines @@
 
   // Remove output stream callback if a stream exists.
   if (stream_writer_)
     stream_writer_->RegisterCallback(base::Closure());
 
   UMA_HISTOGRAM_TIMES("SB2.DownloadDuration",
                       base::TimeTicks::Now() - download_start_time_);
 }
 
 }  // namespace content