Remove deprecated NonThreadSafe usage in net\socket.

net/socket/udp_socket_win.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/socket/udp_socket_win.h"
 
 #include <mstcpip.h>
 
 #include "base/callback.h"
 #include "base/lazy_instance.h"
@@ skipping 252 matching lines @@
       qos_handle_(NULL),
       qos_flow_id_(0) {
   EnsureWinsockInit();
   net_log_.BeginEvent(NetLogEventType::SOCKET_ALIVE,
                       source.ToEventParametersCallback());
   if (bind_type == DatagramSocket::RANDOM_BIND)
     DCHECK(!rand_int_cb.is_null());
 }
 
 UDPSocketWin::~UDPSocketWin() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   Close();
   net_log_.EndEvent(NetLogEventType::SOCKET_ALIVE);
 }
 
 int UDPSocketWin::Open(AddressFamily address_family) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_EQ(socket_, INVALID_SOCKET);
 
   addr_family_ = ConvertAddressFamily(address_family);
   socket_ = CreatePlatformSocket(addr_family_, SOCK_DGRAM, IPPROTO_UDP);
   if (socket_ == INVALID_SOCKET)
     return MapSystemError(WSAGetLastError());
   if (!use_non_blocking_io_) {
     core_ = new Core(this);
   } else {
     read_write_event_.Set(WSACreateEvent());
     WSAEventSelect(socket_, read_write_event_.Get(), FD_READ | FD_WRITE);
   }
   return OK;
 }
 
 void UDPSocketWin::Close() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (socket_ == INVALID_SOCKET)
     return;
 
   if (qos_handle_) {
     QwaveAPI::Get().CloseHandle(qos_handle_);
   }
 
   // Zero out any pending read/write callback state.
   read_callback_.Reset();
@@ skipping 11 matching lines @@
   read_write_watcher_.StopWatching();
   read_write_event_.Close();
 
   if (core_) {
     core_->Detach();
     core_ = NULL;
   }
 }
 
 int UDPSocketWin::GetPeerAddress(IPEndPoint* address) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(address);
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
   // TODO(szym): Simplify. http://crbug.com/126152
   if (!remote_address_.get()) {
     SockaddrStorage storage;
     if (getpeername(socket_, storage.addr, &storage.addr_len))
       return MapSystemError(WSAGetLastError());
     std::unique_ptr<IPEndPoint> remote_address(new IPEndPoint());
     if (!remote_address->FromSockAddr(storage.addr, storage.addr_len))
       return ERR_ADDRESS_INVALID;
     remote_address_ = std::move(remote_address);
   }
 
   *address = *remote_address_;
   return OK;
 }
 
 int UDPSocketWin::GetLocalAddress(IPEndPoint* address) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(address);
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
   // TODO(szym): Simplify. http://crbug.com/126152
   if (!local_address_.get()) {
     SockaddrStorage storage;
     if (getsockname(socket_, storage.addr, &storage.addr_len))
       return MapSystemError(WSAGetLastError());
     std::unique_ptr<IPEndPoint> local_address(new IPEndPoint());
@@ skipping 13 matching lines @@
 int UDPSocketWin::Read(IOBuffer* buf,
                        int buf_len,
                        const CompletionCallback& callback) {
   return RecvFrom(buf, buf_len, NULL, callback);
 }
 
 int UDPSocketWin::RecvFrom(IOBuffer* buf,
                            int buf_len,
                            IPEndPoint* address,
                            const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_NE(INVALID_SOCKET, socket_);
   CHECK(read_callback_.is_null());
   DCHECK(!recv_from_address_);
   DCHECK(!callback.is_null());  // Synchronous operation not supported.
   DCHECK_GT(buf_len, 0);
 
   int nread = core_ ? InternalRecvFromOverlapped(buf, buf_len, address)
                     : InternalRecvFromNonBlocking(buf, buf_len, address);
   if (nread != ERR_IO_PENDING)
     return nread;
@@ skipping 13 matching lines @@
                          int buf_len,
                          const IPEndPoint& address,
                          const CompletionCallback& callback) {
   return SendToOrWrite(buf, buf_len, &address, callback);
 }
 
 int UDPSocketWin::SendToOrWrite(IOBuffer* buf,
                                 int buf_len,
                                 const IPEndPoint* address,
                                 const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_NE(INVALID_SOCKET, socket_);
   CHECK(write_callback_.is_null());
   DCHECK(!callback.is_null());  // Synchronous operation not supported.
   DCHECK_GT(buf_len, 0);
   DCHECK(!send_to_address_.get());
 
   int nwrite = core_ ? InternalSendToOverlapped(buf, buf_len, address)
                      : InternalSendToNonBlocking(buf, buf_len, address);
   if (nwrite != ERR_IO_PENDING)
     return nwrite;
@@ skipping 65 matching lines @@
   return rv;
 }
 
 int UDPSocketWin::BindToNetwork(NetworkChangeNotifier::NetworkHandle network) {
   NOTIMPLEMENTED();
   return ERR_NOT_IMPLEMENTED;
 }
 
 int UDPSocketWin::SetReceiveBufferSize(int32_t size) {
   DCHECK_NE(socket_, INVALID_SOCKET);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   int rv = SetSocketReceiveBufferSize(socket_, size);
 
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
 
   // According to documentation, setsockopt may succeed, but we need to check
   // the results via getsockopt to be sure it works on Windows.
   int32_t actual_size = 0;
   int option_size = sizeof(actual_size);
   rv = getsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
                   reinterpret_cast<char*>(&actual_size), &option_size);
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
   if (actual_size >= size)
     return OK;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SocketUnchangeableReceiveBuffer",
                               actual_size, 1000, 1000000, 50);
   return ERR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE;
 }
 
 int UDPSocketWin::SetSendBufferSize(int32_t size) {
   DCHECK_NE(socket_, INVALID_SOCKET);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   int rv = SetSocketSendBufferSize(socket_, size);
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
   // According to documentation, setsockopt may succeed, but we need to check
   // the results via getsockopt to be sure it works on Windows.
   int32_t actual_size = 0;
   int option_size = sizeof(actual_size);
   rv = getsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
                   reinterpret_cast<char*>(&actual_size), &option_size);
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
   if (actual_size >= size)
     return OK;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SocketUnchangeableSendBuffer",
                               actual_size, 1000, 1000000, 50);
   return ERR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE;
 }
 
 int UDPSocketWin::SetDoNotFragment() {
   DCHECK_NE(socket_, INVALID_SOCKET);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (addr_family_ == AF_INET6)
     return OK;
 
   DWORD val = 1;
   int rv = setsockopt(socket_, IPPROTO_IP, IP_DONTFRAGMENT,
                       reinterpret_cast<const char*>(&val), sizeof(val));
   return rv == 0 ? OK : MapSystemError(WSAGetLastError());
 }
 
 int UDPSocketWin::AllowAddressReuse() {
   DCHECK_NE(socket_, INVALID_SOCKET);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!is_connected());
 
   BOOL true_value = TRUE;
   int rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR,
                       reinterpret_cast<const char*>(&true_value),
                       sizeof(true_value));
   return rv == 0 ? OK : MapSystemError(WSAGetLastError());
 }
 
 int UDPSocketWin::SetBroadcast(bool broadcast) {
   DCHECK_NE(socket_, INVALID_SOCKET);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   BOOL value = broadcast ? TRUE : FALSE;
   int rv = setsockopt(socket_, SOL_SOCKET, SO_BROADCAST,
                       reinterpret_cast<const char*>(&value), sizeof(value));
   return rv == 0 ? OK : MapSystemError(WSAGetLastError());
 }
 
 void UDPSocketWin::DoReadCallback(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
   DCHECK(!read_callback_.is_null());
@@ skipping 399 matching lines @@
   for (int i = 0; i < kBindRetries; ++i) {
     int rv = DoBind(IPEndPoint(address, static_cast<uint16_t>(rand_int_cb_.Run(
                                             kPortStart, kPortEnd))));
     if (rv != ERR_ADDRESS_IN_USE)
       return rv;
   }
   return DoBind(IPEndPoint(address, 0));
 }
 
 int UDPSocketWin::JoinGroup(const IPAddress& group_address) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
   switch (group_address.size()) {
     case IPAddress::kIPv4AddressSize: {
       if (addr_family_ != AF_INET)
         return ERR_ADDRESS_INVALID;
       ip_mreq mreq;
       mreq.imr_interface.s_addr = htonl(multicast_interface_);
       memcpy(&mreq.imr_multiaddr, group_address.bytes().data(),
@@ skipping 19 matching lines @@
         return MapSystemError(WSAGetLastError());
       return OK;
     }
     default:
       NOTREACHED() << "Invalid address family";
       return ERR_ADDRESS_INVALID;
   }
 }
 
 int UDPSocketWin::LeaveGroup(const IPAddress& group_address) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
   switch (group_address.size()) {
     case IPAddress::kIPv4AddressSize: {
       if (addr_family_ != AF_INET)
         return ERR_ADDRESS_INVALID;
       ip_mreq mreq;
       mreq.imr_interface.s_addr = htonl(multicast_interface_);
       memcpy(&mreq.imr_multiaddr, group_address.bytes().data(),
@@ skipping 17 matching lines @@
         return MapSystemError(WSAGetLastError());
       return OK;
     }
     default:
       NOTREACHED() << "Invalid address family";
       return ERR_ADDRESS_INVALID;
   }
 }
 
 int UDPSocketWin::SetMulticastInterface(uint32_t interface_index) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (is_connected())
     return ERR_SOCKET_IS_CONNECTED;
   multicast_interface_ = interface_index;
   return OK;
 }
 
 int UDPSocketWin::SetMulticastTimeToLive(int time_to_live) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (is_connected())
     return ERR_SOCKET_IS_CONNECTED;
 
   if (time_to_live < 0 || time_to_live > 255)
     return ERR_INVALID_ARGUMENT;
   multicast_time_to_live_ = time_to_live;
   return OK;
 }
 
 int UDPSocketWin::SetMulticastLoopbackMode(bool loopback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (is_connected())
     return ERR_SOCKET_IS_CONNECTED;
 
   if (loopback)
     socket_options_ |= SOCKET_OPTION_MULTICAST_LOOP;
   else
     socket_options_ &= ~SOCKET_OPTION_MULTICAST_LOOP;
   return OK;
 }
 
@@ skipping 84 matching lines @@
               QOSSetOutgoingDSCPValue,
               sizeof(buf),
               &buf,
               0,
               NULL);
 
   return OK;
 }
 
 void UDPSocketWin::DetachFromThread() {
-  base::NonThreadSafe::DetachFromThread();
+  DETACH_FROM_THREAD(thread_checker_);
 }
 
 void UDPSocketWin::UseNonBlockingIO() {
   DCHECK(!core_);
   use_non_blocking_io_ = true;
 }
 
 }  // namespace net