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

net/http/http_stream_parser.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/http/http_stream_parser.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/values.h"
@@ skipping 230 matching lines @@
   // If we have a small request body, then we'll merge with the headers into a
   // single write.
   bool did_merge = false;
   if (ShouldMergeRequestHeadersAndBody(request, request_->upload_data_stream)) {
     size_t merged_size = request.size() + request_->upload_data_stream->size();
     scoped_refptr<IOBuffer> merged_request_headers_and_body(
         new IOBuffer(merged_size));
     // We'll repurpose |request_headers_| to store the merged headers and
     // body.
     request_headers_ = new DrainableIOBuffer(
-        merged_request_headers_and_body, merged_size);
+        merged_request_headers_and_body.get(), merged_size);
 
     memcpy(request_headers_->data(), request.data(), request.size());
     request_headers_->DidConsume(request.size());
 
     size_t todo = request_->upload_data_stream->size();
     while (todo) {
-      int consumed = request_->upload_data_stream->Read(request_headers_, todo,
-                                                        CompletionCallback());
+      int consumed = request_->upload_data_stream
+          ->Read(request_headers_.get(), todo, CompletionCallback());
       DCHECK_GT(consumed, 0);  // Read() won't fail if not chunked.
       request_headers_->DidConsume(consumed);
       todo -= consumed;
     }
     DCHECK(request_->upload_data_stream->IsEOF());
     // Reset the offset, so the buffer can be read from the beginning.
     request_headers_->SetOffset(0);
     did_merge = true;
 
     net_log_.AddEvent(
         NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_BODY,
         base::Bind(&NetLogSendRequestBodyCallback,
                    request_->upload_data_stream->size(),
                    false, /* not chunked */
                    true /* merged */));
   }
 
   if (!did_merge) {
     // If we didn't merge the body with the headers, then |request_headers_|
     // contains just the HTTP headers.
     scoped_refptr<StringIOBuffer> headers_io_buf(new StringIOBuffer(request));
-    request_headers_ = new DrainableIOBuffer(headers_io_buf,
-                                             headers_io_buf->size());
+    request_headers_ =
+        new DrainableIOBuffer(headers_io_buf.get(), headers_io_buf->size());
   }
 
   result = DoLoop(OK);
   if (result == ERR_IO_PENDING)
     callback_ = callback;
 
   return result > 0 ? OK : result;
 }
 
 int HttpStreamParser::ReadResponseHeaders(const CompletionCallback& callback) {
@@ skipping 122 matching lines @@
 
 int HttpStreamParser::DoSendHeaders(int result) {
   request_headers_->DidConsume(result);
   int bytes_remaining = request_headers_->BytesRemaining();
   if (bytes_remaining > 0) {
     // Record our best estimate of the 'request time' as the time when we send
     // out the first bytes of the request headers.
     if (bytes_remaining == request_headers_->size()) {
       response_->request_time = base::Time::Now();
     }
-    result = connection_->socket()->Write(request_headers_,
-                                          bytes_remaining,
-                                          io_callback_);
+    result = connection_->socket()
+        ->Write(request_headers_.get(), bytes_remaining, io_callback_);
   } else if (request_->upload_data_stream != NULL &&
              (request_->upload_data_stream->is_chunked() ||
               // !IsEOF() indicates that the body wasn't merged.
               (request_->upload_data_stream->size() > 0 &&
                !request_->upload_data_stream->IsEOF()))) {
     net_log_.AddEvent(
         NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_BODY,
         base::Bind(&NetLogSendRequestBodyCallback,
                    request_->upload_data_stream->size(),
                    request_->upload_data_stream->is_chunked(),
                    false /* not merged */));
     io_state_ = STATE_SENDING_BODY;
     result = OK;
   } else {
     io_state_ = STATE_REQUEST_SENT;
   }
   return result;
 }
 
 int HttpStreamParser::DoSendBody(int result) {
   // |result| is the number of bytes sent from the last call to
   // DoSendBody(), or 0 (i.e. OK).
 
   // Send the remaining data in the request body buffer.
   request_body_send_buf_->DidConsume(result);
   if (request_body_send_buf_->BytesRemaining() > 0) {
-    return connection_->socket()->Write(
-        request_body_send_buf_,
-        request_body_send_buf_->BytesRemaining(),
-        io_callback_);
+    return connection_->socket()
+        ->Write(request_body_send_buf_.get(),
+                request_body_send_buf_->BytesRemaining(),
+                io_callback_);
   }
 
   if (request_->upload_data_stream->is_chunked() && sent_last_chunk_) {
     io_state_ = STATE_REQUEST_SENT;
     return OK;
   }
 
   request_body_read_buf_->Clear();
   io_state_ = STATE_SEND_REQUEST_READING_BODY;
-  return request_->upload_data_stream->Read(request_body_read_buf_,
+  return request_->upload_data_stream->Read(request_body_read_buf_.get(),
                                             request_body_read_buf_->capacity(),
                                             io_callback_);
 }
 
 int HttpStreamParser::DoSendRequestReadingBody(int result) {
   // |result| is the result of read from the request body from the last call to
   // DoSendBody().
   DCHECK_GE(result, 0);  // There won't be errors.
 
   // Chunked data needs to be encoded.
@@ skipping 28 matching lines @@
   io_state_ = STATE_READ_HEADERS_COMPLETE;
 
   // Grow the read buffer if necessary.
   if (read_buf_->RemainingCapacity() == 0)
     read_buf_->SetCapacity(read_buf_->capacity() + kHeaderBufInitialSize);
 
   // http://crbug.com/16371: We're seeing |user_buf_->data()| return NULL.
   // See if the user is passing in an IOBuffer with a NULL |data_|.
   CHECK(read_buf_->data());
 
-  return connection_->socket()->Read(read_buf_,
-                                     read_buf_->RemainingCapacity(),
-                                     io_callback_);
+  return connection_->socket()
+      ->Read(read_buf_.get(), read_buf_->RemainingCapacity(), io_callback_);
 }
 
 int HttpStreamParser::DoReadHeadersComplete(int result) {
   if (result == 0)
     result = ERR_CONNECTION_CLOSED;
 
   if (result < 0 && result != ERR_CONNECTION_CLOSED) {
     io_state_ = STATE_DONE;
     return result;
   }
@@ skipping 114 matching lines @@
       read_buf_->SetCapacity(0);
       read_buf_unused_offset_ = 0;
     }
   }
 
   // Check to see if we're done reading.
   if (IsResponseBodyComplete())
     return 0;
 
   DCHECK_EQ(0, read_buf_->offset());
-  return connection_->socket()->Read(user_read_buf_, user_read_buf_len_,
-                                     io_callback_);
+  return connection_->socket()
+      ->Read(user_read_buf_.get(), user_read_buf_len_, io_callback_);
 }
 
 int HttpStreamParser::DoReadBodyComplete(int result) {
   // When the connection is closed, there are numerous ways to interpret it.
   //
   //  - If a Content-Length header is present and the body contains exactly that
   //    number of bytes at connection close, the response is successful.
   //
   //  - If a Content-Length header is present and the body contains fewer bytes
   //    than promised by the header at connection close, it may indicate that
@@ skipping 123 matching lines @@
         read_buf_->StartOfBuffer() + read_buf_unused_offset_, end_offset));
   } else {
     // Enough data was read -- there is no status line.
     headers = new HttpResponseHeaders(std::string("HTTP/0.9 200 OK"));
   }
 
   // Check for multiple Content-Length headers with no Transfer-Encoding header.
   // If they exist, and have distinct values, it's a potential response
   // smuggling attack.
   if (!headers->HasHeader("Transfer-Encoding")) {
-    if (HeadersContainMultipleCopiesOfField(*headers, "Content-Length"))
+    if (HeadersContainMultipleCopiesOfField(*headers.get(), "Content-Length"))
       return ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH;
   }
 
   // Check for multiple Content-Disposition or Location headers.  If they exist,
   // it's also a potential response smuggling attack.
-  if (HeadersContainMultipleCopiesOfField(*headers, "Content-Disposition"))
+  if (HeadersContainMultipleCopiesOfField(*headers.get(),
+                                          "Content-Disposition"))
     return ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION;
-  if (HeadersContainMultipleCopiesOfField(*headers, "Location"))
+  if (HeadersContainMultipleCopiesOfField(*headers.get(), "Location"))
     return ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION;
 
   response_->headers = headers;
   response_->connection_info = HttpResponseInfo::CONNECTION_INFO_HTTP1;
-  response_->vary_data.Init(*request_, *response_->headers);
+  response_->vary_data.Init(*request_, *response_->headers.get());
   DVLOG(1) << __FUNCTION__ << "()"
-           << " content_length = \""
-           << response_->headers->GetContentLength() << "\n\""
-           << " headers = \"" << GetResponseHeaderLines(*response_->headers)
-           << "\"";
+           << " content_length = \"" << response_->headers->GetContentLength()
+           << "\n\""
+           << " headers = \""
+           << GetResponseHeaderLines(*response_->headers.get()) << "\"";
   return OK;
 }
 
 void HttpStreamParser::CalculateResponseBodySize() {
   // Figure how to determine EOF:
 
   // For certain responses, we know the content length is always 0. From
   // RFC 2616 Section 4.3 Message Body:
   //
   // For response messages, whether or not a message-body is included with
@@ skipping 120 matching lines @@
       request_body->IsInMemory() &&
       request_body->size() > 0) {
     size_t merged_size = request_headers.size() + request_body->size();
     if (merged_size <= kMaxMergedHeaderAndBodySize)
       return true;
   }
   return false;
 }
 
 }  // namespace net