Remove implicit conversions from scoped_refptr to T* in net/

net/socket/tcp_socket_win.cc

 // Copyright 2013 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/socket/tcp_socket.h"
 #include "net/socket/tcp_socket_win.h"
 
 #include <mstcpip.h>
 
 #include "base/callback_helpers.h"
@@ skipping 306 matching lines @@
     return result;
   }
 
   return OK;
 }
 
 int TCPSocketWin::AdoptConnectedSocket(SOCKET socket,
                                        const IPEndPoint& peer_address) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(socket_, INVALID_SOCKET);
-  DCHECK(!core_);
+  DCHECK(!core_.get());
 
   socket_ = socket;
 
   if (SetNonBlocking(socket_)) {
     int result = MapSystemError(WSAGetLastError());
     Close();
     return result;
   }
 
   core_ = new Core(this);
@@ skipping 91 matching lines @@
   DCHECK(!waiting_connect_);
 
   // |peer_address_| and |core_| will be non-NULL if Connect() has been called.
   // Unless Close() is called to reset the internal state, a second call to
   // Connect() is not allowed.
   // Please note that we enforce this even if the previous Connect() has
   // completed and failed. Although it is allowed to connect the same |socket_|
   // again after a connection attempt failed on Windows, it results in
   // unspecified behavior according to POSIX. Therefore, we make it behave in
   // the same way as TCPSocketLibevent.
-  DCHECK(!peer_address_ && !core_);
+  DCHECK(!peer_address_ && !core_.get());
 
   if (!logging_multiple_connect_attempts_)
     LogConnectBegin(AddressList(address));
 
   peer_address_.reset(new IPEndPoint(address));
 
   int rv = DoConnect();
   if (rv == ERR_IO_PENDING) {
     // Synchronous operation not supported.
     DCHECK(!callback.is_null());
@@ skipping 47 matching lines @@
   return true;
 }
 
 int TCPSocketWin::Read(IOBuffer* buf,
                        int buf_len,
                        const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(!waiting_read_);
   CHECK(read_callback_.is_null());
-  DCHECK(!core_->read_iobuffer_);
+  DCHECK(!core_->read_iobuffer_.get());
 
   return DoRead(buf, buf_len, callback);
 }
 
 int TCPSocketWin::Write(IOBuffer* buf,
                         int buf_len,
                         const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(!waiting_write_);
   CHECK(write_callback_.is_null());
   DCHECK_GT(buf_len, 0);
-  DCHECK(!core_->write_iobuffer_);
+  DCHECK(!core_->write_iobuffer_.get());
 
   base::StatsCounter writes("tcp.writes");
   writes.Increment();
 
   WSABUF write_buffer;
   write_buffer.len = buf_len;
   write_buffer.buf = buf->data();
 
   // TODO(wtc): Remove the assertion after enough testing.
   AssertEventNotSignaled(core_->write_overlapped_.hEvent);
@@ skipping 151 matching lines @@
     accept_socket_ = NULL;
     accept_address_ = NULL;
     accept_callback_.Reset();
   }
 
   if (accept_event_) {
     WSACloseEvent(accept_event_);
     accept_event_ = WSA_INVALID_EVENT;
   }
 
-  if (core_) {
+  if (core_.get()) {
     if (waiting_connect_) {
       // We closed the socket, so this notification will never come.
       // From MSDN' WSAEventSelect documentation:
       // "Closing a socket with closesocket also cancels the association and
       // selection of network events specified in WSAEventSelect for the
       // socket".
       core_->Release();
     }
     core_->Detach();
     core_ = NULL;
@@ skipping 86 matching lines @@
     DCHECK(ev.lNetworkEvents == 0);
 
     // Start watching the next FD_ACCEPT event.
     WSAEventSelect(socket_, accept_event_, FD_ACCEPT);
     accept_watcher_.StartWatching(accept_event_, this);
   }
 }
 
 int TCPSocketWin::DoConnect() {
   DCHECK_EQ(connect_os_error_, 0);
-  DCHECK(!core_);
+  DCHECK(!core_.get());
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
                       CreateNetLogIPEndPointCallback(peer_address_.get()));
 
   core_ = new Core(this);
   // WSAEventSelect sets the socket to non-blocking mode as a side effect.
   // Our connect() and recv() calls require that the socket be non-blocking.
   WSAEventSelect(socket_, core_->read_overlapped_.hEvent, FD_CONNECT);
 
   SockaddrStorage storage;
@@ skipping 201 matching lines @@
     // WSAAsyncSelect recommend we still call DoRead():
     //   FD_CLOSE should only be posted after all data is read from a
     //   socket, but an application should check for remaining data upon
     //   receipt of FD_CLOSE to avoid any possibility of losing data.
     //
     // If network_events.iErrorCode[FD_READ_BIT] or
     // network_events.iErrorCode[FD_CLOSE_BIT] is nonzero, still call
     // DoRead() because recv() reports a more accurate error code
     // (WSAECONNRESET vs. WSAECONNABORTED) when the connection was
     // reset.
-    rv = DoRead(core_->read_iobuffer_, core_->read_buffer_length_,
+    rv = DoRead(core_->read_iobuffer_.get(), core_->read_buffer_length_,
                 read_callback_);
     if (rv == ERR_IO_PENDING)
       return;
   } else {
     // This may happen because Read() may succeed synchronously and
     // consume all the received data without resetting the event object.
     core_->WatchForRead();
     return;
   }
 
   waiting_read_ = false;
   core_->read_iobuffer_ = NULL;
   core_->read_buffer_length_ = 0;
 
   DCHECK_NE(rv, ERR_IO_PENDING);
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/418183 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("TCPSocketWin::DidSignalRead"));
   base::ResetAndReturn(&read_callback_).Run(rv);
 }
 
 }  // namespace net