Remove implicit scoped_refptr operator T*

net/spdy/spdy_http_stream.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_http_stream.h"
 
 #include <algorithm>
 #include <list>
 #include <string>
 
@@ skipping 32 matching lines @@
       more_read_data_pending_(false),
       direct_(direct) { }
 
 void SpdyHttpStream::InitializeWithExistingStream(SpdyStream* spdy_stream) {
   stream_ = spdy_stream;
   stream_->SetDelegate(this);
   response_headers_received_ = true;
 }
 
 SpdyHttpStream::~SpdyHttpStream() {
-  if (stream_)
+  if (stream_.get())
     stream_->DetachDelegate();
 }
 
 int SpdyHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      const BoundNetLog& stream_net_log,
                                      const CompletionCallback& callback) {
   DCHECK(!stream_.get());
   if (spdy_session_->IsClosed())
    return ERR_CONNECTION_CLOSED;
 
@@ skipping 71 matching lines @@
       }
       bytes_read += bytes_to_copy;
     }
     stream_->IncreaseRecvWindowSize(bytes_read);
     return bytes_read;
   } else if (stream_->closed()) {
     return stream_->response_status();
   }
 
   CHECK(callback_.is_null());
-  CHECK(!user_buffer_);
+  CHECK(!user_buffer_.get());
   CHECK_EQ(0, user_buffer_len_);
 
   callback_ = callback;
   user_buffer_ = buf;
   user_buffer_len_ = buf_len;
   return ERR_IO_PENDING;
 }
 
 void SpdyHttpStream::Close(bool not_reusable) {
   // Note: the not_reusable flag has no meaning for SPDY streams.
 
   Cancel();
 }
 
 HttpStream* SpdyHttpStream::RenewStreamForAuth() {
   return NULL;
 }
 
 bool SpdyHttpStream::IsResponseBodyComplete() const {
-  if (!stream_)
+  if (!stream_.get())
     return false;
   return stream_->closed();
 }
 
 bool SpdyHttpStream::CanFindEndOfResponse() const {
   return true;
 }
 
 bool SpdyHttpStream::IsMoreDataBuffered() const {
   return false;
@@ skipping 38 matching lines @@
     response_info_->request_time = request_time;
 
   CHECK(!request_body_stream_.get());
   if (request_body != NULL) {
     if (request_body->size() || request_body->is_chunked()) {
       request_body_stream_.reset(request_body.release());
       // Use kMaxSpdyFrameChunkSize as the buffer size, since the request
       // body data is written with this size at a time.
       raw_request_body_buf_ = new IOBufferWithSize(kMaxSpdyFrameChunkSize);
       // The request body buffer is empty at first.
-      request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_, 0);
+      request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), 0);
     }
   }
 
   CHECK(!callback.is_null());
   CHECK(!stream_->cancelled());
   CHECK(response);
 
   if (!stream_->pushed() && stream_->closed()) {
     if (stream_->response_status() == OK)
       return ERR_FAILED;
@@ skipping 26 matching lines @@
   bool has_upload_data = request_body_stream_.get() != NULL;
   result = stream_->SendRequest(has_upload_data);
   if (result == ERR_IO_PENDING) {
     CHECK(callback_.is_null());
     callback_ = callback;
   }
   return result;
 }
 
 void SpdyHttpStream::Cancel() {
-  if (spdy_session_)
+  if (spdy_session_.get())
     spdy_session_->CancelPendingCreateStreams(&stream_);
   callback_.Reset();
-  if (stream_)
+  if (stream_.get())
     stream_->Cancel();
 }
 
 int SpdyHttpStream::SendData() {
   CHECK(request_body_stream_.get());
   CHECK_EQ(0, request_body_buf_->BytesRemaining());
 
   // Read the data from the request body stream.
   const int bytes_read = request_body_stream_->Read(
-      raw_request_body_buf_, raw_request_body_buf_->size(),
+      raw_request_body_buf_.get(), raw_request_body_buf_->size(),
       base::Bind(
           base::IgnoreResult(&SpdyHttpStream::OnRequestBodyReadCompleted),
           weak_factory_.GetWeakPtr()));
 
   if (bytes_read == ERR_IO_PENDING)
     return ERR_IO_PENDING;
   // ERR_IO_PENDING is the only possible error.
   DCHECK_GE(bytes_read, 0);
   return OnRequestBodyReadCompleted(bytes_read);
 }
 
 bool SpdyHttpStream::OnSendHeadersComplete(int status) {
   if (!callback_.is_null())
     DoCallback(status);
   return request_body_stream_.get() == NULL;
 }
 
 int SpdyHttpStream::OnSendBody() {
   CHECK(request_body_stream_.get());
   const bool eof = request_body_stream_->IsEOF();
   if (request_body_buf_->BytesRemaining() > 0) {
     return stream_->WriteStreamData(
-        request_body_buf_,
+        request_body_buf_.get(),
         request_body_buf_->BytesRemaining(),
         eof ? DATA_FLAG_FIN : DATA_FLAG_NONE);
   }
 
   // The entire body data has been sent.
   if (eof)
     return OK;
 
   return SendData();
 }
@@ skipping 46 matching lines @@
   // Don't store the SSLInfo in the response here, HttpNetworkTransaction
   // will take care of that part.
   SSLInfo ssl_info;
   NextProto protocol_negotiated = kProtoUnknown;
   stream_->GetSSLInfo(&ssl_info,
                       &response_info_->was_npn_negotiated,
                       &protocol_negotiated);
   response_info_->npn_negotiated_protocol =
       SSLClientSocket::NextProtoToString(protocol_negotiated);
   response_info_->request_time = stream_->GetRequestTime();
-  response_info_->vary_data.Init(*request_info_, *response_info_->headers);
+  response_info_->
+      vary_data.Init(*request_info_, *response_info_->headers.get());
   // TODO(ahendrickson): This is recorded after the entire SYN_STREAM control
   // frame has been received and processed.  Move to framer?
   response_info_->response_time = response_time;
 
   if (!callback_.is_null())
     DoCallback(status);
 
   return status;
 }
 
@@ skipping 12 matching lines @@
   // Note that data may be received for a SpdyStream prior to the user calling
   // ReadResponseBody(), therefore user_buffer_ may be NULL.  This may often
   // happen for server initiated streams.
   DCHECK(!stream_->closed() || stream_->pushed());
   if (length > 0) {
     // Save the received data.
     IOBufferWithSize* io_buffer = new IOBufferWithSize(length);
     memcpy(io_buffer->data(), data, length);
     response_body_.push_back(make_scoped_refptr(io_buffer));
 
-    if (user_buffer_) {
+    if (user_buffer_.get()) {
       // Handing small chunks of data to the caller creates measurable overhead.
       // We buffer data in short time-spans and send a single read notification.
       ScheduleBufferedReadCallback();
     }
   }
   return OK;
 }
 
 void SpdyHttpStream::OnDataSent(int length) {
   // For HTTP streams, no data is sent from the client while in the OPEN state,
@@ skipping 45 matching lines @@
 
   return bytes_buffered < user_buffer_len_;
 }
 
 bool SpdyHttpStream::DoBufferedReadCallback() {
   weak_factory_.InvalidateWeakPtrs();
   buffered_read_callback_pending_ = false;
 
   // If the transaction is cancelled or errored out, we don't need to complete
   // the read.
-  if (!stream_ || stream_->response_status() != OK || stream_->cancelled())
+  if (
+      !stream_.get() || stream_->response_status() != OK || stream_->
+      cancelled())
     return false;
 
   // When more_read_data_pending_ is true, it means that more data has
   // arrived since we started waiting.  Wait a little longer and continue
   // to buffer.
   if (more_read_data_pending_ && ShouldWaitForMoreBufferedData()) {
     ScheduleBufferedReadCallback();
     return false;
   }
 
   int rv = 0;
-  if (user_buffer_) {
-    rv = ReadResponseBody(user_buffer_, user_buffer_len_, callback_);
+  if (user_buffer_.get()) {
+    rv = ReadResponseBody(user_buffer_.get(), user_buffer_len_, callback_);
     CHECK_NE(rv, ERR_IO_PENDING);
     user_buffer_ = NULL;
     user_buffer_len_ = 0;
     DoCallback(rv);
     return true;
   }
   return false;
 }
 
 void SpdyHttpStream::DoCallback(int rv) {
   CHECK_NE(rv, ERR_IO_PENDING);
   CHECK(!callback_.is_null());
 
   // Since Run may result in being called back, clear user_callback_ in advance.
   CompletionCallback c = callback_;
   callback_.Reset();
   c.Run(rv);
 }
 
 int SpdyHttpStream::OnRequestBodyReadCompleted(int status) {
   DCHECK_GE(status, 0);
 
-  request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_, status);
+  request_body_buf_ =
+      new DrainableIOBuffer(raw_request_body_buf_.get(), status);
 
   const bool eof = request_body_stream_->IsEOF();
-  return stream_->WriteStreamData(request_body_buf_,
+  return stream_->WriteStreamData(request_body_buf_.get(),
                                   request_body_buf_->BytesRemaining(),
                                   eof ? DATA_FLAG_FIN : DATA_FLAG_NONE);
 }
 
 void SpdyHttpStream::GetSSLInfo(SSLInfo* ssl_info) {
   DCHECK(stream_);
   bool using_npn;
   NextProto protocol_negotiated = kProtoUnknown;
   stream_->GetSSLInfo(ssl_info, &using_npn, &protocol_negotiated);
 }
 
 void SpdyHttpStream::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   DCHECK(stream_);
   stream_->GetSSLCertRequestInfo(cert_request_info);
 }
 
 bool SpdyHttpStream::IsSpdyHttpStream() const {
   return true;
 }
 
 void SpdyHttpStream::Drain(HttpNetworkSession* session) {
   Close(false);
   delete this;
 }
 
 }  // namespace net