Remove implicit scoped_refptr 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 38 matching lines @@
                                      user_agent);
   spdy_stream_->SetDelegate(this);
   was_ever_used_ = spdy_stream_->WasEverUsed();
 }
 
 SpdyProxyClientSocket::~SpdyProxyClientSocket() {
   Disconnect();
 }
 
 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 49 matching lines @@
   read_buffer_.clear();
   user_buffer_ = NULL;
   read_callback_.Reset();
 
   write_buffer_len_ = 0;
   write_bytes_outstanding_ = 0;
   write_callback_.Reset();
 
   next_state_ = STATE_DISCONNECTED;
 
-  if (spdy_stream_)
+  if (spdy_stream_.get())
     // This will cause OnClose to be invoked, which takes care of
     // cleaning up all the internal state.
     spdy_stream_->Cancel();
 }
 
 bool SpdyProxyClientSocket::IsConnected() const {
   return next_state_ == STATE_OPEN;
 }
 
 bool SpdyProxyClientSocket::IsConnectedAndIdle() const {
   return IsConnected() && read_buffer_.empty() && spdy_stream_->is_idle();
 }
 
 const BoundNetLog& SpdyProxyClientSocket::NetLog() const {
   return net_log_;
 }
 
 void SpdyProxyClientSocket::SetSubresourceSpeculation() {
   // TODO(rch): what should this implementation be?
 }
 
 void SpdyProxyClientSocket::SetOmniboxSpeculation() {
   // TODO(rch): what should this implementation be?
 }
 
 bool SpdyProxyClientSocket::WasEverUsed() const {
-  return was_ever_used_ || (spdy_stream_ && spdy_stream_->WasEverUsed());
+  return was_ever_used_ || (spdy_stream_.get() && spdy_stream_->WasEverUsed());
 }
 
 bool SpdyProxyClientSocket::UsingTCPFastOpen() const {
   return false;
 }
 
 int64 SpdyProxyClientSocket::NumBytesRead() const {
   return -1;
 }
 
@@ skipping 12 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_.empty()) {
     return 0;
   }
 
   DCHECK(next_state_ == STATE_OPEN || next_state_ == STATE_CLOSED);
   DCHECK(buf);
   user_buffer_ = new DrainableIOBuffer(buf, buf_len);
   int result = PopulateUserReadBuffer();
   if (result == 0) {
     DCHECK(!callback.is_null());
     read_callback_ = callback;
     return ERR_IO_PENDING;
   }
   user_buffer_ = NULL;
   return result;
 }
 
 int SpdyProxyClientSocket::PopulateUserReadBuffer() {
-  if (!user_buffer_)
+  if (!user_buffer_.get())
     return ERR_IO_PENDING;
 
   int bytes_read = 0;
   while (!read_buffer_.empty() && user_buffer_->BytesRemaining() > 0) {
     scoped_refptr<DrainableIOBuffer> data = read_buffer_.front();
     const int bytes_to_copy = std::min(user_buffer_->BytesRemaining(),
                                        data->BytesRemaining());
     memcpy(user_buffer_->data(), data->data(), bytes_to_copy);
     user_buffer_->DidConsume(bytes_to_copy);
     bytes_read += bytes_to_copy;
     if (data->BytesRemaining() == bytes_to_copy) {
       // Consumed all data from this buffer
       read_buffer_.pop_front();
     } else {
       data->DidConsume(bytes_to_copy);
     }
   }
 
-  if (bytes_read > 0 && spdy_stream_)
+  if (bytes_read > 0 && spdy_stream_.get())
     spdy_stream_->IncreaseRecvWindowSize(bytes_read);
 
   return user_buffer_->BytesConsumed();
 }
 
 int SpdyProxyClientSocket::Write(IOBuffer* buf, int buf_len,
                                  const CompletionCallback& callback) {
   DCHECK(write_callback_.is_null());
   if (next_state_ != STATE_OPEN)
     return ERR_SOCKET_NOT_CONNECTED;
 
   DCHECK(spdy_stream_);
   write_bytes_outstanding_= buf_len;
   if (buf_len <= kMaxSpdyFrameChunkSize) {
     int rv = spdy_stream_->WriteStreamData(buf, buf_len, DATA_FLAG_NONE);
     if (rv == ERR_IO_PENDING) {
       write_callback_ = callback;
       write_buffer_len_ = buf_len;
     }
     return rv;
   }
 
   // Since a SPDY Data frame can only include kMaxSpdyFrameChunkSize bytes
   // we need to send multiple data frames
   for (int i = 0; i < buf_len; i += kMaxSpdyFrameChunkSize) {
     int len = std::min(kMaxSpdyFrameChunkSize, buf_len - i);
     scoped_refptr<DrainableIOBuffer> iobuf(new DrainableIOBuffer(buf, i + len));
     iobuf->SetOffset(i);
-    int rv = spdy_stream_->WriteStreamData(iobuf, len, DATA_FLAG_NONE);
+    int rv = spdy_stream_->WriteStreamData(iobuf.get(), len, DATA_FLAG_NONE);
     if (rv > 0) {
       write_bytes_outstanding_ -= rv;
     } else if (rv != ERR_IO_PENDING) {
       return rv;
     }
   }
   if (write_bytes_outstanding_ > 0) {
     write_callback_ = callback;
     write_buffer_len_ = buf_len;
     return ERR_IO_PENDING;
@@ skipping 165 matching lines @@
       return OK;
 
     case 302:  // Found / Moved Temporarily
       // Try to return a sanitized response so we can follow auth redirects.
       // If we can't, fail the tunnel connection.
       if (SanitizeProxyRedirect(&response_, request_.url)) {
         // Immediately hand off our SpdyStream to a newly created
         // SpdyHttpStream so that any subsequent SpdyFrames are processed in
         // the context of the HttpStream, not the socket.
         DCHECK(spdy_stream_);
-        SpdyStream* stream = spdy_stream_;
+        SpdyStream* stream = spdy_stream_.get();
         spdy_stream_ = NULL;
         response_stream_.reset(new SpdyHttpStream(NULL, false));
         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 47 matching lines @@
   NOTREACHED();
 }
 
 // Called when data is received.
 int SpdyProxyClientSocket::OnDataReceived(const char* data, int length) {
   if (length > 0) {
     // Save the received data.
     scoped_refptr<IOBuffer> io_buffer(new IOBuffer(length));
     memcpy(io_buffer->data(), data, length);
     read_buffer_.push_back(
-        make_scoped_refptr(new DrainableIOBuffer(io_buffer, length)));
+        make_scoped_refptr(new DrainableIOBuffer(io_buffer.get(), length)));
   }
 
   if (!read_callback_.is_null()) {
     int rv = PopulateUserReadBuffer();
     CompletionCallback c = read_callback_;
     read_callback_.Reset();
     user_buffer_ = NULL;
     c.Run(rv);
   }
   return OK;
@@ skipping 44 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(NULL, 0);
   }
   // 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