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

net/spdy/spdy_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_stream.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 379 matching lines @@
       // For a bidirectional stream, we're ready for the response
       // headers once we've finished sending the request headers.
       if (io_state_ < STATE_OPEN)
         return ERR_SPDY_PROTOCOL_ERROR;
       break;
 
     case SPDY_REQUEST_RESPONSE_STREAM:
       // For a request/response stream, we're ready for the response
       // headers once we've finished sending the request headers and
       // the request body (if we have one).
-      if ((io_state_ < STATE_OPEN) ||
-          (send_status_ == MORE_DATA_TO_SEND) ||
-          pending_send_data_)
+      if ((io_state_ < STATE_OPEN) || (send_status_ == MORE_DATA_TO_SEND) ||
+          pending_send_data_.get())
         return ERR_SPDY_PROTOCOL_ERROR;
       break;
 
     case SPDY_PUSH_STREAM:
       // For a push stream, we're ready immediately.
       DCHECK_EQ(send_status_, NO_MORE_DATA_TO_SEND);
       DCHECK_EQ(io_state_, STATE_OPEN);
       break;
   }
 
@@ skipping 176 matching lines @@
   } else {
     session_->CloseCreatedStream(GetWeakPtr(), OK);
   }
 }
 
 int SpdyStream::SendRequestHeaders(scoped_ptr<SpdyHeaderBlock> headers,
                                    SpdySendStatus send_status) {
   CHECK_NE(type_, SPDY_PUSH_STREAM);
   CHECK_EQ(send_status_, MORE_DATA_TO_SEND);
   CHECK(!request_);
-  CHECK(!pending_send_data_);
+  CHECK(!pending_send_data_.get());
   CHECK_EQ(io_state_, STATE_NONE);
   request_ = headers.Pass();
   send_status_ = send_status;
   io_state_ = STATE_GET_DOMAIN_BOUND_CERT;
   return DoLoop(OK);
 }
 
 void SpdyStream::SendData(IOBuffer* data,
                           int length,
                           SpdySendStatus send_status) {
   CHECK_NE(type_, SPDY_PUSH_STREAM);
   CHECK_EQ(send_status_, MORE_DATA_TO_SEND);
   CHECK_GE(io_state_, STATE_SEND_REQUEST_HEADERS_COMPLETE);
-  CHECK(!pending_send_data_);
+  CHECK(!pending_send_data_.get());
   pending_send_data_ = new DrainableIOBuffer(data, length);
   send_status_ = send_status;
   QueueNextDataFrame();
 }
 
 bool SpdyStream::GetSSLInfo(SSLInfo* ssl_info,
                             bool* was_npn_negotiated,
                             NextProto* protocol_negotiated) {
   return session_->GetSSLInfo(
       ssl_info, was_npn_negotiated, protocol_negotiated);
@@ skipping 315 matching lines @@
 
   UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_);
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 void SpdyStream::QueueNextDataFrame() {
   // Until the request has been completely sent, we cannot be sure
   // that our stream_id is correct.
   DCHECK_GT(io_state_, STATE_SEND_REQUEST_HEADERS_COMPLETE);
   CHECK_GT(stream_id_, 0u);
-  CHECK(pending_send_data_);
+  CHECK(pending_send_data_.get());
   CHECK_GT(pending_send_data_->BytesRemaining(), 0);
 
   SpdyDataFlags flags =
       (send_status_ == NO_MORE_DATA_TO_SEND) ?
       DATA_FLAG_FIN : DATA_FLAG_NONE;
-  scoped_ptr<SpdyBuffer> data_buffer(session_->CreateDataBuffer(
-      stream_id_,
-      pending_send_data_, pending_send_data_->BytesRemaining(),
-      flags));
+  scoped_ptr<SpdyBuffer> data_buffer(
+      session_->CreateDataBuffer(stream_id_,
+                                 pending_send_data_.get(),
+                                 pending_send_data_->BytesRemaining(),
+                                 flags));
   // We'll get called again by PossiblyResumeIfSendStalled().
   if (!data_buffer)
     return;
 
   if (session_->flow_control_state() >= SpdySession::FLOW_CONTROL_STREAM) {
     DCHECK_GE(data_buffer->GetRemainingSize(),
               session_->GetDataFrameMinimumSize());
     size_t payload_size =
         data_buffer->GetRemainingSize() - session_->GetDataFrameMinimumSize();
     DCHECK_LE(payload_size, session_->GetDataFrameMaximumPayload());
     DecreaseSendWindowSize(static_cast<int32>(payload_size));
     // This currently isn't strictly needed, since write frames are
     // discarded only if the stream is about to be closed. But have it
     // here anyway just in case this changes.
     data_buffer->AddConsumeCallback(
         base::Bind(&SpdyStream::OnWriteBufferConsumed,
                    GetWeakPtr(), payload_size));
   }
 
   session_->EnqueueStreamWrite(
       GetWeakPtr(), DATA,
       scoped_ptr<SpdyBufferProducer>(
           new SimpleBufferProducer(data_buffer.Pass())));
 }
 
 }  // namespace net