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

net/spdy/spdy_session.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_session.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 226 matching lines @@
   CancelRequest();
 }
 
 int SpdyStreamRequest::StartRequest(
     SpdyStreamType type,
     const scoped_refptr<SpdySession>& session,
     const GURL& url,
     RequestPriority priority,
     const BoundNetLog& net_log,
     const CompletionCallback& callback) {
-  DCHECK(session);
-  DCHECK(!session_);
+  DCHECK(session.get());
+  DCHECK(!session_.get());
   DCHECK(!stream_);
   DCHECK(callback_.is_null());
 
   type_ = type;
   session_ = session;
   url_ = url;
   priority_ = priority;
   net_log_ = net_log;
   callback_ = callback;
 
   base::WeakPtr<SpdyStream> stream;
   int rv = session->TryCreateStream(this, &stream);
   if (rv == OK) {
     Reset();
     stream_ = stream;
   }
   return rv;
 }
 
 void SpdyStreamRequest::CancelRequest() {
-  if (session_)
+  if (session_.get())
     session_->CancelStreamRequest(this);
   Reset();
 }
 
 base::WeakPtr<SpdyStream> SpdyStreamRequest::ReleaseStream() {
   DCHECK(!session_.get());
   base::WeakPtr<SpdyStream> stream = stream_;
   DCHECK(stream);
   Reset();
   return stream;
 }
 
 void SpdyStreamRequest::OnRequestCompleteSuccess(
     base::WeakPtr<SpdyStream>* stream) {
-  DCHECK(session_);
+  DCHECK(session_.get());
   DCHECK(!stream_);
   DCHECK(!callback_.is_null());
   CompletionCallback callback = callback_;
   Reset();
   DCHECK(*stream);
   stream_ = *stream;
   callback.Run(OK);
 }
 
 void SpdyStreamRequest::OnRequestCompleteFailure(int rv) {
-  DCHECK(session_);
+  DCHECK(session_.get());
   DCHECK(!stream_);
   DCHECK(!callback_.is_null());
   CompletionCallback callback = callback_;
   Reset();
   DCHECK_NE(rv, OK);
   callback.Run(rv);
 }
 
 void SpdyStreamRequest::Reset() {
   type_ = SPDY_BIDIRECTIONAL_STREAM;
@@ skipping 887 matching lines @@
     write_pending_ = true;
     // Explicitly store in a scoped_refptr<IOBuffer> to avoid problems
     // with Socket implementations that don't store their IOBuffer
     // argument in a scoped_refptr<IOBuffer> (see crbug.com/232345).
     scoped_refptr<IOBuffer> write_io_buffer =
         in_flight_write_->GetIOBufferForRemainingData();
     // We keep |in_flight_write_| alive until OnWriteComplete(), so
     // it's okay to use GetIOBufferForRemainingData() since the socket
     // doesn't use the IOBuffer past OnWriteComplete().
     int rv = connection_->socket()->Write(
-        write_io_buffer,
+        write_io_buffer.get(),
         in_flight_write_->GetRemainingSize(),
         base::Bind(&SpdySession::OnWriteComplete, weak_factory_.GetWeakPtr()));
     // Avoid persisting |write_io_buffer| past |in_flight_write_|'s
     // lifetime (which will end if OnWriteComplete() is called below).
     write_io_buffer = NULL;
     if (rv == ERR_IO_PENDING)
       break;
 
     // We sent the frame successfully.
     OnWriteComplete(rv);
@@ skipping 1240 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net