Make TCPClientSocket* inherit from NonThreadSafe.

net/socket/tcp_client_socket_libevent.cc

 // Copyright (c) 2010 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_client_socket_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
@@ skipping 126 matching lines @@
       write_callback_(NULL),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
 }
 
 TCPClientSocketLibevent::~TCPClientSocketLibevent() {
   Disconnect();
   net_log_.AddEvent(NetLog::TYPE_TCP_SOCKET_DONE, NULL);
 }
 
 int TCPClientSocketLibevent::Connect(CompletionCallback* callback) {
+  DCHECK(CalledOnValidThread());
+
   // If already connected, then just return OK.
   if (socket_ != kInvalidSocket)
     return OK;
 
   DCHECK(!waiting_connect_);
 
   TRACE_EVENT_BEGIN("socket.connect", this, "");
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT, NULL);
 
@@ skipping 54 matching lines @@
     DLOG(INFO) << "WatchFileDescriptor failed: " << errno;
     close(socket_);
     socket_ = kInvalidSocket;
     return MapPosixError(errno);
   }
 
   return ERR_IO_PENDING;
 }
 
 void TCPClientSocketLibevent::Disconnect() {
+  DCHECK(CalledOnValidThread());
+
   if (socket_ == kInvalidSocket)
     return;
 
   TRACE_EVENT_INSTANT("socket.disconnect", this, "");
 
   bool ok = read_socket_watcher_.StopWatchingFileDescriptor();
   DCHECK(ok);
   ok = write_socket_watcher_.StopWatchingFileDescriptor();
   DCHECK(ok);
   close(socket_);
   socket_ = kInvalidSocket;
   waiting_connect_ = false;
 
   // Reset for next time.
   current_ai_ = addresses_.head();
 }
 
 bool TCPClientSocketLibevent::IsConnected() const {
+  DCHECK(CalledOnValidThread());
+
   if (socket_ == kInvalidSocket || waiting_connect_)
     return false;
 
   // Check if connection is alive.
   char c;
   int rv = HANDLE_EINTR(recv(socket_, &c, 1, MSG_PEEK));
   if (rv == 0)
     return false;
   if (rv == -1 && errno != EAGAIN && errno != EWOULDBLOCK)
     return false;
 
   return true;
 }
 
 bool TCPClientSocketLibevent::IsConnectedAndIdle() const {
+  DCHECK(CalledOnValidThread());
+
   if (socket_ == kInvalidSocket || waiting_connect_)
     return false;
 
   // Check if connection is alive and we haven't received any data
   // unexpectedly.
   char c;
   int rv = HANDLE_EINTR(recv(socket_, &c, 1, MSG_PEEK));
   if (rv >= 0)
     return false;
   if (errno != EAGAIN && errno != EWOULDBLOCK)
     return false;
 
   return true;
 }
 
 int TCPClientSocketLibevent::Read(IOBuffer* buf,
                                   int buf_len,
                                   CompletionCallback* callback) {
+  DCHECK(CalledOnValidThread());
   DCHECK_NE(kInvalidSocket, socket_);
   DCHECK(!waiting_connect_);
   DCHECK(!read_callback_);
   // Synchronous operation not supported
   DCHECK(callback);
   DCHECK_GT(buf_len, 0);
 
   TRACE_EVENT_BEGIN("socket.read", this, "");
   int nread = HANDLE_EINTR(read(socket_, buf->data(), buf_len));
   if (nread >= 0) {
@@ skipping 16 matching lines @@
 
   read_buf_ = buf;
   read_buf_len_ = buf_len;
   read_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int TCPClientSocketLibevent::Write(IOBuffer* buf,
                                    int buf_len,
                                    CompletionCallback* callback) {
+  DCHECK(CalledOnValidThread());
   DCHECK_NE(kInvalidSocket, socket_);
   DCHECK(!waiting_connect_);
   DCHECK(!write_callback_);
   // Synchronous operation not supported
   DCHECK(callback);
   DCHECK_GT(buf_len, 0);
 
   TRACE_EVENT_BEGIN("socket.write", this, "");
   int nwrite = HANDLE_EINTR(write(socket_, buf->data(), buf_len));
   if (nwrite >= 0) {
@@ skipping 13 matching lines @@
   }
 
 
   write_buf_ = buf;
   write_buf_len_ = buf_len;
   write_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 bool TCPClientSocketLibevent::SetReceiveBufferSize(int32 size) {
+  DCHECK(CalledOnValidThread());
   int rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
       reinterpret_cast<const char*>(&size),
       sizeof(size));
   DCHECK(!rv) << "Could not set socket receive buffer size: " << errno;
   return rv == 0;
 }
 
 bool TCPClientSocketLibevent::SetSendBufferSize(int32 size) {
+  DCHECK(CalledOnValidThread());
   int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
       reinterpret_cast<const char*>(&size),
       sizeof(size));
   DCHECK(!rv) << "Could not set socket send buffer size: " << errno;
   return rv == 0;
 }
 
 
 int TCPClientSocketLibevent::CreateSocket(const addrinfo* ai) {
   socket_ = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
@@ skipping 111 matching lines @@
 
   if (result != ERR_IO_PENDING) {
     write_buf_ = NULL;
     write_buf_len_ = 0;
     write_socket_watcher_.StopWatchingFileDescriptor();
     DoWriteCallback(result);
   }
 }
 
 int TCPClientSocketLibevent::GetPeerAddress(AddressList* address) const {
+  DCHECK(CalledOnValidThread());
   DCHECK(address);
   if (!current_ai_)
     return ERR_UNEXPECTED;
   address->Copy(current_ai_, false);
   return OK;
 }
 
 }  // namespace net