Remove deprecated NonThreadSafe usage in net\socket.

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 <errno.h>
 #include <mstcpip.h>
 
@@ skipping 241 matching lines @@
       waiting_write_(false),
       connect_os_error_(0),
       logging_multiple_connect_attempts_(false),
       net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)) {
   net_log_.BeginEvent(NetLogEventType::SOCKET_ALIVE,
                       source.ToEventParametersCallback());
   EnsureWinsockInit();
 }
 
 TCPSocketWin::~TCPSocketWin() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   Close();
   net_log_.EndEvent(NetLogEventType::SOCKET_ALIVE);
 }
 
 int TCPSocketWin::Open(AddressFamily family) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_EQ(socket_, INVALID_SOCKET);
 
   socket_ = CreatePlatformSocket(ConvertAddressFamily(family), SOCK_STREAM,
                                  IPPROTO_TCP);
   int os_error = WSAGetLastError();
   if (socket_ == INVALID_SOCKET) {
     PLOG(ERROR) << "CreatePlatformSocket() returned an error";
     return MapSystemError(os_error);
   }
 
   if (!SetNonBlockingAndGetError(socket_, &os_error)) {
     int result = MapSystemError(os_error);
     Close();
     return result;
   }
 
   return OK;
 }
 
 int TCPSocketWin::AdoptConnectedSocket(SocketDescriptor socket,
                                        const IPEndPoint& peer_address) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_EQ(socket_, INVALID_SOCKET);
   DCHECK(!core_.get());
 
   socket_ = socket;
 
   int os_error;
   if (!SetNonBlockingAndGetError(socket_, &os_error)) {
     int result = MapSystemError(os_error);
     Close();
     return result;
   }
 
   core_ = new Core(this);
   peer_address_.reset(new IPEndPoint(peer_address));
 
   return OK;
 }
 
 int TCPSocketWin::AdoptUnconnectedSocket(SocketDescriptor socket) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_EQ(socket_, INVALID_SOCKET);
 
   socket_ = socket;
 
   int os_error;
   if (!SetNonBlockingAndGetError(socket_, &os_error)) {
     int result = MapSystemError(os_error);
     Close();
     return result;
   }
 
   // |core_| is not needed for sockets that are used to accept connections.
   // The operation here is more like Open but with an existing socket.
 
   return OK;
 }
 
 int TCPSocketWin::Bind(const IPEndPoint& address) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_NE(socket_, INVALID_SOCKET);
 
   SockaddrStorage storage;
   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_ADDRESS_INVALID;
 
   int result = bind(socket_, storage.addr, storage.addr_len);
   int os_error = WSAGetLastError();
   if (result < 0) {
     PLOG(ERROR) << "bind() returned an error";
     return MapSystemError(os_error);
   }
 
   return OK;
 }
 
 int TCPSocketWin::Listen(int backlog) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_GT(backlog, 0);
   DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK_EQ(accept_event_, WSA_INVALID_EVENT);
 
   accept_event_ = WSACreateEvent();
   int os_error = WSAGetLastError();
   if (accept_event_ == WSA_INVALID_EVENT) {
     PLOG(ERROR) << "WSACreateEvent()";
     return MapSystemError(os_error);
   }
 
   int result = listen(socket_, backlog);
   os_error = WSAGetLastError();
   if (result < 0) {
     PLOG(ERROR) << "listen() returned an error";
     return MapSystemError(os_error);
   }
 
   return OK;
 }
 
 int TCPSocketWin::Accept(std::unique_ptr<TCPSocketWin>* socket,
                          IPEndPoint* address,
                          const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(socket);
   DCHECK(address);
   DCHECK(!callback.is_null());
   DCHECK(accept_callback_.is_null());
 
   net_log_.BeginEvent(NetLogEventType::TCP_ACCEPT);
 
   int result = AcceptInternal(socket, address);
 
   if (result == ERR_IO_PENDING) {
     // Start watching.
     WSAEventSelect(socket_, accept_event_, FD_ACCEPT);
     accept_watcher_.StartWatchingOnce(accept_event_, this);
 
     accept_socket_ = socket;
     accept_address_ = address;
     accept_callback_ = callback;
   }
 
   return result;
 }
 
 int TCPSocketWin::Connect(const IPEndPoint& address,
                           const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_NE(socket_, INVALID_SOCKET);
   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
@@ skipping 12 matching lines @@
     read_callback_ = callback;
     waiting_connect_ = true;
   } else {
     DoConnectComplete(rv);
   }
 
   return rv;
 }
 
 bool TCPSocketWin::IsConnected() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (socket_ == INVALID_SOCKET || waiting_connect_)
     return false;
 
   if (waiting_read_)
     return true;
 
   // Check if connection is alive.
   char c;
   int rv = recv(socket_, &c, 1, MSG_PEEK);
   int os_error = WSAGetLastError();
   if (rv == 0)
     return false;
   if (rv == SOCKET_ERROR && os_error != WSAEWOULDBLOCK)
     return false;
 
   return true;
 }
 
 bool TCPSocketWin::IsConnectedAndIdle() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (socket_ == INVALID_SOCKET || waiting_connect_)
     return false;
 
   if (waiting_read_)
     return true;
 
   // Check if connection is alive and we haven't received any data
   // unexpectedly.
   char c;
   int rv = recv(socket_, &c, 1, MSG_PEEK);
   int os_error = WSAGetLastError();
   if (rv >= 0)
     return false;
   if (os_error != WSAEWOULDBLOCK)
     return false;
 
   return true;
 }
 
 int TCPSocketWin::Read(IOBuffer* buf,
                        int buf_len,
                        const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!core_->read_iobuffer_.get());
   // base::Unretained() is safe because RetryRead() won't be called when |this|
   // is gone.
   int rv =
       ReadIfReady(buf, buf_len,
                   base::Bind(&TCPSocketWin::RetryRead, base::Unretained(this)));
   if (rv != ERR_IO_PENDING)
     return rv;
   read_callback_ = callback;
   core_->read_iobuffer_ = buf;
   core_->read_buffer_length_ = buf_len;
   return ERR_IO_PENDING;
 }
 
 int TCPSocketWin::ReadIfReady(IOBuffer* buf,
                               int buf_len,
                               const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(!waiting_read_);
   DCHECK(read_if_ready_callback_.is_null());
 
   if (!core_->non_blocking_reads_initialized_) {
     WSAEventSelect(socket_, core_->read_overlapped_.hEvent, FD_READ | FD_CLOSE);
     core_->non_blocking_reads_initialized_ = true;
   }
   int rv = recv(socket_, buf->data(), buf_len, 0);
   int os_error = WSAGetLastError();
@@ skipping 13 matching lines @@
 
   waiting_read_ = true;
   read_if_ready_callback_ = callback;
   core_->WatchForRead();
   return ERR_IO_PENDING;
 }
 
 int TCPSocketWin::Write(IOBuffer* buf,
                         int buf_len,
                         const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(!waiting_write_);
   CHECK(write_callback_.is_null());
   DCHECK_GT(buf_len, 0);
   DCHECK(!core_->write_iobuffer_.get());
 
   WSABUF write_buffer;
   write_buffer.len = buf_len;
   write_buffer.buf = buf->data();
 
@@ skipping 28 matching lines @@
   }
   waiting_write_ = true;
   write_callback_ = callback;
   core_->write_iobuffer_ = buf;
   core_->write_buffer_length_ = buf_len;
   core_->WatchForWrite();
   return ERR_IO_PENDING;
 }
 
 int TCPSocketWin::GetLocalAddress(IPEndPoint* address) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(address);
 
   SockaddrStorage storage;
   if (getsockname(socket_, storage.addr, &storage.addr_len)) {
     int os_error = WSAGetLastError();
     return MapSystemError(os_error);
   }
   if (!address->FromSockAddr(storage.addr, storage.addr_len))
     return ERR_ADDRESS_INVALID;
 
   return OK;
 }
 
 int TCPSocketWin::GetPeerAddress(IPEndPoint* address) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(address);
   if (!IsConnected())
     return ERR_SOCKET_NOT_CONNECTED;
   *address = *peer_address_;
   return OK;
 }
 
 int TCPSocketWin::SetDefaultOptionsForServer() {
   return SetExclusiveAddrUse();
 }
@@ skipping 23 matching lines @@
   BOOL true_value = 1;
   int rv = setsockopt(socket_, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
                       reinterpret_cast<const char*>(&true_value),
                       sizeof(true_value));
   if (rv < 0)
     return MapSystemError(errno);
   return OK;
 }
 
 int TCPSocketWin::SetReceiveBufferSize(int32_t size) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   return SetSocketReceiveBufferSize(socket_, size);
 }
 
 int TCPSocketWin::SetSendBufferSize(int32_t size) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   return SetSocketSendBufferSize(socket_, size);
 }
 
 bool TCPSocketWin::SetKeepAlive(bool enable, int delay) {
   return SetTCPKeepAlive(socket_, enable, delay);
 }
 
 bool TCPSocketWin::SetNoDelay(bool no_delay) {
   return SetTCPNoDelay(socket_, no_delay) == OK;
 }
 
 void TCPSocketWin::Close() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (socket_ != INVALID_SOCKET) {
     // Only log the close event if there's actually a socket to close.
     net_log_.AddEvent(NetLogEventType::SOCKET_CLOSED);
 
     // Note: don't use CancelIo to cancel pending IO because it doesn't work
     // when there is a Winsock layered service provider.
 
     // In most socket implementations, closing a socket results in a graceful
     // connection shutdown, but in Winsock we have to call shutdown explicitly.
@@ skipping 37 matching lines @@
   waiting_write_ = false;
 
   read_callback_.Reset();
   read_if_ready_callback_.Reset();
   write_callback_.Reset();
   peer_address_.reset();
   connect_os_error_ = 0;
 }
 
 void TCPSocketWin::DetachFromThread() {
-  base::NonThreadSafe::DetachFromThread();
+  DETACH_FROM_THREAD(thread_checker_);
 }
 
 void TCPSocketWin::StartLoggingMultipleConnectAttempts(
     const AddressList& addresses) {
   if (!logging_multiple_connect_attempts_) {
     logging_multiple_connect_attempts_ = true;
     LogConnectBegin(addresses);
   } else {
     NOTREACHED();
   }
@@ skipping 322 matching lines @@
 }
 
 bool TCPSocketWin::GetEstimatedRoundTripTime(base::TimeDelta* out_rtt) const {
   DCHECK(out_rtt);
   // TODO(bmcquade): Consider implementing using
   // GetPerTcpConnectionEStats/GetPerTcp6ConnectionEStats.
   return false;
 }
 
 }  // namespace net