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

net/http/http_proxy_client_socket.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 "net/http/http_proxy_client_socket.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 77 matching lines @@
 
 bool HttpProxyClientSocket::IsUsingSpdy() const {
   return using_spdy_;
 }
 
 NextProto HttpProxyClientSocket::GetProtocolNegotiated() const {
   return protocol_negotiated_;
 }
 
 const HttpResponseInfo* HttpProxyClientSocket::GetConnectResponseInfo() const {
-  return response_.headers ? &response_ : NULL;
+  return response_.headers.get() ? &response_ : NULL;
 }
 
 HttpStream* HttpProxyClientSocket::CreateConnectResponseStream() {
   return new HttpBasicStream(transport_.release(),
                              http_stream_parser_.release(), false);
 }
 
 
 int HttpProxyClientSocket::Connect(const CompletionCallback& callback) {
   DCHECK(transport_.get());
@@ skipping 298 matching lines @@
                        &request_line_, &request_headers_);
 
     net_log_.AddEvent(
         NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
         base::Bind(&HttpRequestHeaders::NetLogCallback,
                    base::Unretained(&request_headers_),
                    &request_line_));
   }
 
   parser_buf_ = new GrowableIOBuffer();
-  http_stream_parser_.reset(
-      new HttpStreamParser(transport_.get(), &request_, parser_buf_, net_log_));
+  http_stream_parser_.reset(new HttpStreamParser(
+      transport_.get(), &request_, parser_buf_.get(), net_log_));
   return http_stream_parser_->SendRequest(
       request_line_, request_headers_, &response_, io_callback_);
 }
 
 int HttpProxyClientSocket::DoSendRequestComplete(int result) {
   if (result < 0)
     return result;
 
   next_state_ = STATE_READ_HEADERS;
   return OK;
@@ skipping 42 matching lines @@
 
       // We're not using an HTTPS proxy, or we couldn't sanitize the redirect.
       LogBlockedTunnelResponse();
       return ERR_TUNNEL_CONNECTION_FAILED;
 
     case 407:  // Proxy Authentication Required
       // We need this status code to allow proxy authentication.  Our
       // authentication code is smart enough to avoid being tricked by an
       // active network attacker.
       // The next state is intentionally not set as it should be STATE_NONE;
-      return HandleProxyAuthChallenge(auth_, &response_, net_log_);
+      return HandleProxyAuthChallenge(auth_.get(), &response_, net_log_);
 
     default:
       // Ignore response to avoid letting the proxy impersonate the target
       // server.  (See http://crbug.com/137891.)
       // We lose something by doing this.  We have seen proxy 403, 404, and
       // 501 response bodies that contain a useful error message.  For
       // example, Squid uses a 404 response to report the DNS error: "The
       // domain name does not exist."
       LogBlockedTunnelResponse();
       return ERR_TUNNEL_CONNECTION_FAILED;
   }
 }
 
 int HttpProxyClientSocket::DoDrainBody() {
-  DCHECK(drain_buf_);
+  DCHECK(drain_buf_.get());
   DCHECK(transport_->is_initialized());
   next_state_ = STATE_DRAIN_BODY_COMPLETE;
-  return http_stream_parser_->ReadResponseBody(drain_buf_, kDrainBodyBufferSize,
-                                               io_callback_);
+  return http_stream_parser_->ReadResponseBody(
+      drain_buf_.get(), kDrainBodyBufferSize, io_callback_);
 }
 
 int HttpProxyClientSocket::DoDrainBodyComplete(int result) {
   if (result < 0)
     return result;
 
   if (http_stream_parser_->IsResponseBodyComplete())
     return DidDrainBodyForAuthRestart(true);
 
   // Keep draining.
   next_state_ = STATE_DRAIN_BODY;
   return OK;
 }
 
 int HttpProxyClientSocket::DoTCPRestart() {
   next_state_ = STATE_TCP_RESTART_COMPLETE;
   return transport_->socket()->Connect(
       base::Bind(&HttpProxyClientSocket::OnIOComplete, base::Unretained(this)));
 }
 
 int HttpProxyClientSocket::DoTCPRestartComplete(int result) {
   if (result != OK)
     return result;
 
   next_state_ = STATE_GENERATE_AUTH_TOKEN;
   return result;
 }
 
 }  // namespace net