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

net/spdy/spdy_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/spdy/spdy_proxy_client_socket.h"
 
 #include <algorithm>  // min
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 49 matching lines @@
   spdy_stream_->SetDelegate(this);
   was_ever_used_ = spdy_stream_->WasEverUsed();
 }
 
 SpdyProxyClientSocket::~SpdyProxyClientSocket() {
   Disconnect();
   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
 }
 
 const HttpResponseInfo* SpdyProxyClientSocket::GetConnectResponseInfo() const {
-  return response_.headers ? &response_ : NULL;
+  return response_.headers.get() ? &response_ : NULL;
 }
 
 const scoped_refptr<HttpAuthController>&
 SpdyProxyClientSocket::GetAuthController() const {
   return auth_;
 }
 
 int SpdyProxyClientSocket::RestartWithAuth(const CompletionCallback& callback) {
   // A SPDY Stream can only handle a single request, so the underlying
   // stream may not be reused and a new SpdyProxyClientSocket must be
@@ skipping 104 matching lines @@
 bool SpdyProxyClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   bool was_npn_negotiated;
   NextProto protocol_negotiated;
   return spdy_stream_->GetSSLInfo(ssl_info, &was_npn_negotiated,
                                   &protocol_negotiated);
 }
 
 int SpdyProxyClientSocket::Read(IOBuffer* buf, int buf_len,
                                 const CompletionCallback& callback) {
   DCHECK(read_callback_.is_null());
-  DCHECK(!user_buffer_);
+  DCHECK(!user_buffer_.get());
 
   if (next_state_ == STATE_DISCONNECTED)
     return ERR_SOCKET_NOT_CONNECTED;
 
   if (next_state_ == STATE_CLOSED && read_buffer_queue_.IsEmpty()) {
     return 0;
   }
 
   DCHECK(next_state_ == STATE_OPEN || next_state_ == STATE_CLOSED);
   DCHECK(buf);
@@ skipping 209 matching lines @@
         response_stream_->InitializeWithExistingStream(stream);
         next_state_ = STATE_DISCONNECTED;
         return ERR_HTTPS_PROXY_TUNNEL_RESPONSE;
       } else {
         LogBlockedTunnelResponse();
         return ERR_TUNNEL_CONNECTION_FAILED;
       }
 
     case 407:  // Proxy Authentication Required
       next_state_ = STATE_OPEN;
-      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.)
       LogBlockedTunnelResponse();
       return ERR_TUNNEL_CONNECTION_FAILED;
   }
 }
 
 // SpdyStream::Delegate methods:
@@ skipping 80 matching lines @@
   } else if (!read_callback_.is_null()) {
     // If we have a read_callback_, the we need to make sure we call it back.
     OnDataReceived(scoped_ptr<SpdyBuffer>());
   }
   // This may have been deleted by read_callback_, so check first.
   if (weak_ptr && !write_callback.is_null())
     write_callback.Run(ERR_CONNECTION_CLOSED);
 }
 
 }  // namespace net