Remove deprecated NonThreadSafe usage in net\socket.

net/socket/udp_socket_posix.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_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <net/if.h>
 #include <netdb.h>
@@ skipping 161 matching lines @@
       write_buf_len_(0),
       net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::UDP_SOCKET)),
       bound_network_(NetworkChangeNotifier::kInvalidNetworkHandle) {
   net_log_.BeginEvent(NetLogEventType::SOCKET_ALIVE,
                       source.ToEventParametersCallback());
   if (bind_type == DatagramSocket::RANDOM_BIND)
     DCHECK(!rand_int_cb.is_null());
 }
 
 UDPSocketPosix::~UDPSocketPosix() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   Close();
   net_log_.EndEvent(NetLogEventType::SOCKET_ALIVE);
 }
 
 int UDPSocketPosix::Open(AddressFamily address_family) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_EQ(socket_, kInvalidSocket);
 
   addr_family_ = ConvertAddressFamily(address_family);
   socket_ = CreatePlatformSocket(addr_family_, SOCK_DGRAM, 0);
   if (socket_ == kInvalidSocket)
     return MapSystemError(errno);
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   PCHECK(change_fdguard_np(socket_, NULL, 0, &kSocketFdGuard,
                            GUARD_CLOSE | GUARD_DUP, NULL) == 0);
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
   if (!base::SetNonBlocking(socket_)) {
     const int err = MapSystemError(errno);
     Close();
     return err;
   }
   return OK;
 }
 
 void UDPSocketPosix::Close() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (socket_ == kInvalidSocket)
     return;
 
   // Zero out any pending read/write callback state.
   read_buf_ = NULL;
   read_buf_len_ = 0;
   read_callback_.Reset();
   recv_from_address_ = NULL;
   write_buf_ = NULL;
@@ skipping 11 matching lines @@
 #else
   PCHECK(IGNORE_EINTR(close(socket_)) == 0);
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
   socket_ = kInvalidSocket;
   addr_family_ = 0;
   is_connected_ = false;
 }
 
 int UDPSocketPosix::GetPeerAddress(IPEndPoint* address) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(address);
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
   if (!remote_address_.get()) {
     SockaddrStorage storage;
     if (getpeername(socket_, storage.addr, &storage.addr_len))
       return MapSystemError(errno);
     std::unique_ptr<IPEndPoint> address(new IPEndPoint());
     if (!address->FromSockAddr(storage.addr, storage.addr_len))
       return ERR_ADDRESS_INVALID;
     remote_address_ = std::move(address);
   }
 
   *address = *remote_address_;
   return OK;
 }
 
 int UDPSocketPosix::GetLocalAddress(IPEndPoint* address) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(address);
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
   if (!local_address_.get()) {
     SockaddrStorage storage;
     if (getsockname(socket_, storage.addr, &storage.addr_len))
       return MapSystemError(errno);
     std::unique_ptr<IPEndPoint> address(new IPEndPoint());
     if (!address->FromSockAddr(storage.addr, storage.addr_len))
@@ skipping 11 matching lines @@
 int UDPSocketPosix::Read(IOBuffer* buf,
                          int buf_len,
                          const CompletionCallback& callback) {
   return RecvFrom(buf, buf_len, NULL, callback);
 }
 
 int UDPSocketPosix::RecvFrom(IOBuffer* buf,
                              int buf_len,
                              IPEndPoint* address,
                              const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_NE(kInvalidSocket, 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 = InternalRecvFrom(buf, buf_len, address);
   if (nread != ERR_IO_PENDING)
     return nread;
 
@@ skipping 23 matching lines @@
                            int buf_len,
                            const IPEndPoint& address,
                            const CompletionCallback& callback) {
   return SendToOrWrite(buf, buf_len, &address, callback);
 }
 
 int UDPSocketPosix::SendToOrWrite(IOBuffer* buf,
                                   int buf_len,
                                   const IPEndPoint* address,
                                   const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_NE(kInvalidSocket, socket_);
   CHECK(write_callback_.is_null());
   DCHECK(!callback.is_null());  // Synchronous operation not supported
   DCHECK_GT(buf_len, 0);
 
   int result = InternalSendTo(buf, buf_len, address);
   if (result != ERR_IO_PENDING)
     return result;
 
   if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
@@ skipping 19 matching lines @@
   DCHECK_NE(socket_, kInvalidSocket);
   net_log_.BeginEvent(NetLogEventType::UDP_CONNECT,
                       CreateNetLogUDPConnectCallback(&address, bound_network_));
   int rv = InternalConnect(address);
   net_log_.EndEventWithNetErrorCode(NetLogEventType::UDP_CONNECT, rv);
   is_connected_ = (rv == OK);
   return rv;
 }
 
 int UDPSocketPosix::InternalConnect(const IPEndPoint& address) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!is_connected());
   DCHECK(!remote_address_.get());
 
   int rv = 0;
   if (bind_type_ == DatagramSocket::RANDOM_BIND) {
     // Construct IPAddress of appropriate size (IPv4 or IPv6) of 0s,
     // representing INADDR_ANY or in6addr_any.
     size_t addr_size = address.GetSockAddrFamily() == AF_INET
                            ? IPAddress::kIPv4AddressSize
                            : IPAddress::kIPv6AddressSize;
@@ skipping 13 matching lines @@
   rv = HANDLE_EINTR(connect(socket_, storage.addr, storage.addr_len));
   if (rv < 0)
     return MapSystemError(errno);
 
   remote_address_.reset(new IPEndPoint(address));
   return rv;
 }
 
 int UDPSocketPosix::Bind(const IPEndPoint& address) {
   DCHECK_NE(socket_, kInvalidSocket);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!is_connected());
 
   int rv = SetMulticastOptions();
   if (rv < 0)
     return rv;
 
   rv = DoBind(address);
   if (rv < 0)
     return rv;
 
   is_connected_ = true;
   local_address_.reset();
   return rv;
 }
 
 int UDPSocketPosix::BindToNetwork(
     NetworkChangeNotifier::NetworkHandle network) {
   DCHECK_NE(socket_, kInvalidSocket);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!is_connected());
   if (network == NetworkChangeNotifier::kInvalidNetworkHandle)
     return ERR_INVALID_ARGUMENT;
 #if defined(OS_ANDROID)
   // Android prior to Lollipop didn't have support for binding sockets to
   // networks.
   if (base::android::BuildInfo::GetInstance()->sdk_int() <
       base::android::SDK_VERSION_LOLLIPOP) {
     return ERR_NOT_IMPLEMENTED;
   }
@@ skipping 55 matching lines @@
     bound_network_ = network;
   return MapSystemError(rv);
 #else
   NOTIMPLEMENTED();
   return ERR_NOT_IMPLEMENTED;
 #endif
 }
 
 int UDPSocketPosix::SetReceiveBufferSize(int32_t size) {
   DCHECK_NE(socket_, kInvalidSocket);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   return SetSocketReceiveBufferSize(socket_, size);
 }
 
 int UDPSocketPosix::SetSendBufferSize(int32_t size) {
   DCHECK_NE(socket_, kInvalidSocket);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   return SetSocketSendBufferSize(socket_, size);
 }
 
 int UDPSocketPosix::SetDoNotFragment() {
   DCHECK_NE(socket_, kInvalidSocket);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
 #if !defined(IP_PMTUDISC_DO)
   return ERR_NOT_IMPLEMENTED;
 #else
   if (addr_family_ == AF_INET6) {
     int val = IPV6_PMTUDISC_DO;
     if (setsockopt(socket_, IPPROTO_IPV6, IPV6_MTU_DISCOVER, &val,
                    sizeof(val)) != 0) {
       return MapSystemError(errno);
     }
@@ skipping 10 matching lines @@
   }
 
   int val = IP_PMTUDISC_DO;
   int rv = setsockopt(socket_, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val));
   return rv == 0 ? OK : MapSystemError(errno);
 #endif
 }
 
 int UDPSocketPosix::AllowAddressReuse() {
   DCHECK_NE(socket_, kInvalidSocket);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!is_connected());
   return SetReuseAddr(socket_, true);
 }
 
 int UDPSocketPosix::SetBroadcast(bool broadcast) {
   DCHECK_NE(socket_, kInvalidSocket);
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   int value = broadcast ? 1 : 0;
   int rv;
 #if defined(OS_MACOSX)
   // SO_REUSEPORT on OSX permits multiple processes to each receive
   // UDP multicast or broadcast datagrams destined for the bound
   // port.
   // This is only being set on OSX because its behavior is platform dependent
   // and we are playing it safe by only setting it on platforms where things
   // break.
   rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value));
@@ skipping 253 matching lines @@
   for (int i = 0; i < kBindRetries; ++i) {
     int rv = DoBind(IPEndPoint(address,
                                rand_int_cb_.Run(kPortStart, kPortEnd)));
     if (rv != ERR_ADDRESS_IN_USE)
       return rv;
   }
   return DoBind(IPEndPoint(address, 0));
 }
 
 int UDPSocketPosix::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;
 
 #if !defined(OS_MACOSX)
       ip_mreqn mreq;
@@ skipping 27 matching lines @@
         return MapSystemError(errno);
       return OK;
     }
     default:
       NOTREACHED() << "Invalid address family";
       return ERR_ADDRESS_INVALID;
   }
 }
 
 int UDPSocketPosix::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 = INADDR_ANY;
@@ skipping 18 matching lines @@
         return MapSystemError(errno);
       return OK;
     }
     default:
       NOTREACHED() << "Invalid address family";
       return ERR_ADDRESS_INVALID;
   }
 }
 
 int UDPSocketPosix::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 UDPSocketPosix::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 UDPSocketPosix::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 10 matching lines @@
     rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_TCLASS,
                     &dscp_and_ecn, sizeof(dscp_and_ecn));
   }
   if (rv < 0)
     return MapSystemError(errno);
 
   return OK;
 }
 
 void UDPSocketPosix::DetachFromThread() {
-  base::NonThreadSafe::DetachFromThread();
+  DETACH_FROM_THREAD(thread_checker_);
 }
 
 }  // namespace net