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

content/browser/loader/buffered_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/buffered_resource_handler.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 101 matching lines @@
   // TODO(darin): It is very odd to special-case 304 responses at this level.
   // We do so only because the code always has, see r24977 and r29355.  The
   // fact that 204 is no longer special-cased this way suggests that 304 need
   // not be special-cased either.
   //
   // The network stack only forwards 304 responses that were not received in
   // response to a conditional request (i.e., If-Modified-Since).  Other 304
   // responses end up being translated to 200 or whatever the cached response
   // code happens to be.  It should be very rare to see a 304 at this level.
 
-  if (!(response_->head.headers &&
+  if (!(response_->head.headers.get() &&
         response_->head.headers->response_code() == 304)) {
     if (ShouldSniffContent()) {
       state_ = STATE_BUFFERING;
       return true;
     }
 
     if (response_->head.mime_type.empty()) {
       // Ugg.  The server told us not to sniff the content but didn't give us
       // a mime type.  What's a browser to do?  Turns out, we're supposed to
       // treat the response as "text/plain".  This is the most secure option.
@@ skipping 13 matching lines @@
 
 // We'll let the original event handler provide a buffer, and reuse it for
 // subsequent reads until we're done buffering.
 bool BufferedResourceHandler::OnWillRead(int request_id, net::IOBuffer** buf,
                                          int* buf_size, int min_size) {
   if (state_ == STATE_STREAMING)
     return next_handler_->OnWillRead(request_id, buf, buf_size, min_size);
 
   DCHECK_EQ(-1, min_size);
 
-  if (read_buffer_) {
+  if (read_buffer_.get()) {
     CHECK_LT(bytes_read_, read_buffer_size_);
-    *buf = new DependentIOBuffer(read_buffer_, bytes_read_);
+    *buf = new DependentIOBuffer(read_buffer_.get(), bytes_read_);
     *buf_size = read_buffer_size_ - bytes_read_;
   } else {
     if (!next_handler_->OnWillRead(request_id, buf, buf_size, min_size))
       return false;
 
     read_buffer_ = *buf;
     read_buffer_size_ = *buf_size;
     DCHECK_GE(read_buffer_size_, net::kMaxBytesToSniff * 2);
   }
   return true;
@@ skipping 53 matching lines @@
 }
 
 void BufferedResourceHandler::CancelWithError(int error_code) {
   controller()->CancelWithError(error_code);
 }
 
 bool BufferedResourceHandler::ProcessResponse(bool* defer) {
   DCHECK_EQ(STATE_PROCESSING, state_);
 
   // TODO(darin): Stop special-casing 304 responses.
-  if (!(response_->head.headers &&
+  if (!(response_->head.headers.get() &&
         response_->head.headers->response_code() == 304)) {
     if (!SelectNextHandler(defer))
       return false;
     if (*defer)
       return true;
   }
 
   state_ = STATE_REPLAYING;
 
   int request_id = ResourceRequestInfo::ForRequest(request_)->GetRequestID();
-  if (!next_handler_->OnResponseStarted(request_id, response_, defer))
+  if (!next_handler_->OnResponseStarted(request_id, response_.get(), defer))
     return false;
 
-  if (!read_buffer_) {
+  if (!read_buffer_.get()) {
     state_ = STATE_STREAMING;
     return true;
   }
 
   if (!*defer)
     return ReplayReadCompleted(defer);
 
   return true;
 }
 
@@ skipping 57 matching lines @@
 
   if (!info->allow_download())
     return true;
 
   bool must_download = MustDownload();
   if (!must_download) {
     if (net::IsSupportedMimeType(mime_type))
       return true;
 
     scoped_ptr<ResourceHandler> handler(
-        host_->MaybeInterceptAsStream(request_, response_));
+        host_->MaybeInterceptAsStream(request_, response_.get()));
     if (handler)
       return UseAlternateNextHandler(handler.Pass());
 
 #if defined(ENABLE_PLUGINS)
     bool stale;
     bool has_plugin = HasSupportingPlugin(&stale);
     if (stale) {
       // Refresh the plugins asynchronously.
       PluginServiceImpl::GetInstance()->GetPlugins(
           base::Bind(&BufferedResourceHandler::OnPluginsLoaded,
@@ skipping 14 matching lines @@
           true,  // is_content_initiated
           must_download,
           DownloadId(),
           scoped_ptr<DownloadSaveInfo>(new DownloadSaveInfo()),
           DownloadResourceHandler::OnStartedCallback()));
   return UseAlternateNextHandler(handler.Pass());
 }
 
 bool BufferedResourceHandler::UseAlternateNextHandler(
     scoped_ptr<ResourceHandler> new_handler) {
-  if (response_->head.headers &&  // Can be NULL if FTP.
+  if (response_->head.headers.get() &&  // Can be NULL if FTP.
       response_->head.headers->response_code() / 100 != 2) {
     // The response code indicates that this is an error page, but we don't
     // know how to display the content.  We follow Firefox here and show our
     // own error page instead of triggering a download.
     // TODO(abarth): We should abstract the response_code test, but this kind
     //               of check is scattered throughout our codebase.
     request_->CancelWithError(net::ERR_FILE_NOT_FOUND);
     return false;
   }
 
   int request_id = ResourceRequestInfo::ForRequest(request_)->GetRequestID();
 
   // Inform the original ResourceHandler that this will be handled entirely by
   // the new ResourceHandler.
   // TODO(darin): We should probably check the return values of these.
   bool defer_ignored = false;
-  next_handler_->OnResponseStarted(request_id, response_, &defer_ignored);
+  next_handler_->OnResponseStarted(request_id, response_.get(), &defer_ignored);
   DCHECK(!defer_ignored);
   net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
                                net::ERR_ABORTED);
   next_handler_->OnResponseCompleted(request_id, status, std::string());
 
   // This is handled entirely within the new ResourceHandler, so just reset the
   // original ResourceHandler.
   next_handler_ = new_handler.Pass();
   next_handler_->SetController(this);
 
   return CopyReadBufferToNextHandler(request_id);
 }
 
 bool BufferedResourceHandler::ReplayReadCompleted(bool* defer) {
-  DCHECK(read_buffer_);
+  DCHECK(read_buffer_.get());
 
   int request_id = ResourceRequestInfo::ForRequest(request_)->GetRequestID();
   bool result = next_handler_->OnReadCompleted(request_id, bytes_read_, defer);
 
   read_buffer_ = NULL;
   read_buffer_size_ = 0;
   bytes_read_ = 0;
 
   state_ = STATE_STREAMING;
 
@@ skipping 61 matching lines @@
     const std::vector<webkit::WebPluginInfo>& plugins) {
   bool defer = false;
   if (!ProcessResponse(&defer)) {
     controller()->Cancel();
   } else if (!defer) {
     controller()->Resume();
   }
 }
 
 }  // namespace content