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

net/quic/quic_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/quic/quic_http_stream.h"
 
 #include "base/callback_helpers.h"
 #include "base/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 71 matching lines @@
   // Store the request body.
   request_body_stream_ = request_info_->upload_data_stream;
   if (request_body_stream_ && (request_body_stream_->size() ||
                                request_body_stream_->is_chunked())) {
     // Use kMaxPacketSize as the buffer size, since the request
     // body data is written with this size at a time.
     // TODO(rch): use a smarter value since we can't write an entire
     // packet due to overhead.
     raw_request_body_buf_ = new IOBufferWithSize(kMaxPacketSize);
     // 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);
   }
 
   // Store the response info.
   response_info_ = response;
 
   next_state_ = STATE_SEND_HEADERS;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
@@ skipping 56 matching lines @@
     }
     return bytes_read;
   }
 
   if (!stream_) {
     // If the stream is already closed, there is no body to read.
     return 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 QuicHttpStream::Close(bool not_reusable) {
   // Note: the not_reusable flag has no meaning for SPDY streams.
@@ skipping 192 matching lines @@
     return rv;
 
   next_state_ = request_body_stream_ ?
       STATE_READ_REQUEST_BODY : STATE_OPEN;
 
   return OK;
 }
 
 int QuicHttpStream::DoReadRequestBody() {
   next_state_ = STATE_READ_REQUEST_BODY_COMPLETE;
-  return request_body_stream_->Read(raw_request_body_buf_,
-                                    raw_request_body_buf_->size(),
-                                    base::Bind(&QuicHttpStream::OnIOComplete,
-                                               weak_factory_.GetWeakPtr()));
+  return request_body_stream_->Read(
+      raw_request_body_buf_.get(),
+      raw_request_body_buf_->size(),
+      base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()));
 }
 
 int QuicHttpStream::DoReadRequestBodyComplete(int rv) {
   // |rv| is the result of read from the request body from the last call to
   // DoSendBody().
   if (rv < 0)
     return rv;
 
-  request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_, rv);
+  request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), rv);
   if (rv == 0) {  // Reached the end.
     DCHECK(request_body_stream_->IsEOF());
   }
 
   next_state_ = STATE_SEND_BODY;
   return OK;
 }
 
 int QuicHttpStream::DoSendBody() {
   if (!stream_)
     return ERR_UNEXPECTED;
 
   CHECK(request_body_stream_);
-  CHECK(request_body_buf_);
+  CHECK(request_body_buf_.get());
   const bool eof = request_body_stream_->IsEOF();
   int len = request_body_buf_->BytesRemaining();
   if (len > 0 || eof) {
     base::StringPiece data(request_body_buf_->data(), len);
     QuicConsumedData rv = stream_->WriteData(data, eof);
     request_body_buf_->DidConsume(rv.bytes_consumed);
     if (eof) {
       next_state_ = STATE_OPEN;
       return OK;
     }
@@ skipping 39 matching lines @@
 
   if (!SpdyHeadersToHttpResponse(headers, 3, response_info_)) {
     DLOG(WARNING) << "Invalid headers";
     return ERR_QUIC_PROTOCOL_ERROR;
   }
   // Put the peer's IP address and port into the response.
   IPEndPoint address = stream_->GetPeerAddress();
   response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
   response_info_->connection_info =
       HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3;
-  response_info_->vary_data.Init(*request_info_, *response_info_->headers);
+  response_info_->vary_data
+      .Init(*request_info_, *response_info_->headers.get());
   response_info_->was_npn_negotiated = true;
   response_info_->npn_negotiated_protocol = "quic/1+spdy/3";
   response_headers_received_ = true;
 
   return OK;
 }
 
 void QuicHttpStream::BufferResponseBody(const char* data, int length) {
   if (length == 0)
     return;
   IOBufferWithSize* io_buffer = new IOBufferWithSize(length);
   memcpy(io_buffer->data(), data, length);
   response_body_.push_back(make_scoped_refptr(io_buffer));
 }
 
 }  // namespace net