Update net/ to use scoped_refptr<T>::get() rather than implicit "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 "base/bind.h"
@@ skipping 123 matching lines @@
   CHECK(!callback.is_null());
 
   // If we have data buffered, complete the IO immediately.
   if (!response_body_queue_.IsEmpty()) {
     return response_body_queue_.Dequeue(buf->data(), buf_len);
   } else if (stream_closed_) {
     return closed_stream_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.
@@ skipping 25 matching lines @@
 bool SpdyHttpStream::IsConnectionReusable() const {
   // SPDY streams aren't considered reusable.
   return false;
 }
 
 bool SpdyHttpStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
   // If |stream_| has yet to be created, or does not yet have an ID, fail.
   // The reused flag can only be correctly set once a stream has an ID.  Streams
   // get their IDs once the request has been successfully sent, so this does not
   // behave that differently from other stream types.
-  if (!spdy_session_ || (!stream_ && !stream_closed_))
+  if (!spdy_session_.get() || (!stream_ && !stream_closed_))
     return false;
 
   SpdyStreamId stream_id =
       stream_closed_ ? closed_stream_id_ : stream_->stream_id();
   if (stream_id == 0)
     return false;
 
   return spdy_session_->GetLoadTimingInfo(stream_id, load_timing_info);
 }
 
@@ skipping 10 matching lines @@
   base::Time request_time = base::Time::Now();
   CHECK(stream_.get());
 
   stream_->SetRequestTime(request_time);
   // This should only get called in the case of a request occurring
   // during server push that has already begun but hasn't finished,
   // so we set the response's request time to be the actual one
   if (response_info_)
     response_info_->request_time = request_time;
 
-  CHECK(!request_body_buf_);
+  CHECK(!request_body_buf_.get());
   if (HasUploadData()) {
     // Use kMaxSpdyFrameChunkSize as the buffer size, since the request
     // body data is written with this size at a time.
     request_body_buf_ = new IOBufferWithSize(kMaxSpdyFrameChunkSize);
     // The request body buffer is empty at first.
     request_body_buf_size_ = 0;
   }
 
   CHECK(!callback.is_null());
   CHECK(response);
@@ skipping 108 matching lines @@
       break;
     case SPDY3:
       response_info_->connection_info = HttpResponseInfo::CONNECTION_INFO_SPDY3;
       break;
     case SPDY4:
       response_info_->connection_info = HttpResponseInfo::CONNECTION_INFO_SPDY4;
       break;
     default:
       NOTREACHED();
   }
-  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;
 }
 
 int SpdyHttpStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
   // SpdyStream won't call us with data if the header block didn't contain a
   // valid set of headers.  So we don't expect to not have headers received
   // here.
   if (!response_headers_received_)
     return ERR_INCOMPLETE_SPDY_HEADERS;
 
   // 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_.get());
   DCHECK(!stream_->closed() || stream_->type() == SPDY_PUSH_STREAM);
   if (buffer) {
     response_body_queue_.Enqueue(buffer.Pass());
 
-    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() {
   request_body_buf_size_ = 0;
@@ skipping 35 matching lines @@
 }
 
 void SpdyHttpStream::ReadAndSendRequestBodyData() {
   CHECK(HasUploadData());
   CHECK_EQ(request_body_buf_size_, 0);
 
   if (request_info_->upload_data_stream->IsEOF())
     return;
 
   // Read the data from the request body stream.
-  const int rv = request_info_->upload_data_stream->Read(
-      request_body_buf_, request_body_buf_->size(),
-      base::Bind(
-          &SpdyHttpStream::OnRequestBodyReadCompleted,
-          weak_factory_.GetWeakPtr()));
+  const int rv = request_info_->upload_data_stream
+      ->Read(request_body_buf_.get(),
+             request_body_buf_->size(),
+             base::Bind(&SpdyHttpStream::OnRequestBodyReadCompleted,
+                        weak_factory_.GetWeakPtr()));
 
   if (rv != ERR_IO_PENDING) {
     // ERR_IO_PENDING is the only possible error.
     CHECK_GE(rv, 0);
     OnRequestBodyReadCompleted(rv);
   }
 }
 
 void SpdyHttpStream::OnRequestBodyReadCompleted(int status) {
   CHECK_GE(status, 0);
   request_body_buf_size_ = status;
   const bool eof = request_info_->upload_data_stream->IsEOF();
   if (eof) {
     CHECK_GE(request_body_buf_size_, 0);
   } else {
     CHECK_GT(request_body_buf_size_, 0);
   }
-  stream_->SendData(request_body_buf_,
+  stream_->SendData(request_body_buf_.get(),
                     request_body_buf_size_,
                     eof ? NO_MORE_DATA_TO_SEND : MORE_DATA_TO_SEND);
 }
 
 void SpdyHttpStream::ScheduleBufferedReadCallback() {
   // If there is already a scheduled DoBufferedReadCallback, don't issue
   // another one.  Mark that we have received more data and return.
   if (buffered_read_callback_pending_) {
     more_read_data_pending_ = true;
     return;
@@ skipping 36 matching lines @@
 
   // 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) {
@@ skipping 22 matching lines @@
 bool SpdyHttpStream::IsSpdyHttpStream() const {
   return true;
 }
 
 void SpdyHttpStream::Drain(HttpNetworkSession* session) {
   Close(false);
   delete this;
 }
 
 }  // namespace net