Make TCPClientSocket* inherit from NonThreadSafe.

net/socket/tcp_client_socket_win.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_win.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory_debug.h"
 #include "base/stats_counters.h"
@@ skipping 274 matching lines @@
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
   EnsureWinsockInit();
 }
 
 TCPClientSocketWin::~TCPClientSocketWin() {
   Disconnect();
   net_log_.AddEvent(NetLog::TYPE_TCP_SOCKET_DONE, NULL);
 }
 
 int TCPClientSocketWin::Connect(CompletionCallback* callback) {
+  DCHECK(CalledOnValidThread());
+
   // If already connected, then just return OK.
   if (socket_ != INVALID_SOCKET)
     return OK;
 
   static StatsCounter connects("tcp.connect");
   connects.Increment();
 
   TRACE_EVENT_BEGIN("socket.connect", this, "");
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT, NULL);
@@ skipping 56 matching lines @@
       LOG(ERROR) << "connect failed: " << os_error;
       return MapConnectError(os_error);
     }
   }
 
   core_->WatchForRead();
   return ERR_IO_PENDING;
 }
 
 void TCPClientSocketWin::Disconnect() {
+  DCHECK(CalledOnValidThread());
+
   if (socket_ == INVALID_SOCKET)
     return;
 
   TRACE_EVENT_INSTANT("socket.disconnect", this, "");
 
   // 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 18 matching lines @@
 
   waiting_read_ = false;
   waiting_write_ = false;
   waiting_connect_ = false;
 
   core_->Detach();
   core_ = NULL;
 }
 
 bool TCPClientSocketWin::IsConnected() const {
+  DCHECK(CalledOnValidThread());
+
   if (socket_ == INVALID_SOCKET || waiting_connect_)
     return false;
 
   // Check if connection is alive.
   char c;
   int rv = recv(socket_, &c, 1, MSG_PEEK);
   if (rv == 0)
     return false;
   if (rv == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
     return false;
 
   return true;
 }
 
 bool TCPClientSocketWin::IsConnectedAndIdle() const {
+  DCHECK(CalledOnValidThread());
+
   if (socket_ == INVALID_SOCKET || waiting_connect_)
     return false;
 
   // Check if connection is alive and we haven't received any data
   // unexpectedly.
   char c;
   int rv = recv(socket_, &c, 1, MSG_PEEK);
   if (rv >= 0)
     return false;
   if (WSAGetLastError() != WSAEWOULDBLOCK)
     return false;
 
   return true;
 }
 
 int TCPClientSocketWin::GetPeerAddress(AddressList* address) const {
+  DCHECK(CalledOnValidThread());
   DCHECK(address);
   if (!current_ai_)
     return ERR_FAILED;
   address->Copy(current_ai_, false);
   return OK;
 }
 
 int TCPClientSocketWin::Read(IOBuffer* buf,
                              int buf_len,
                              CompletionCallback* callback) {
+  DCHECK(CalledOnValidThread());
   DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(!waiting_read_);
   DCHECK(!read_callback_);
   DCHECK(!core_->read_iobuffer_);
 
   buf_len = core_->ThrottleReadSize(buf_len);
 
   core_->read_buffer_.len = buf_len;
   core_->read_buffer_.buf = buf->data();
 
@@ skipping 29 matching lines @@
   core_->WatchForRead();
   waiting_read_ = true;
   read_callback_ = callback;
   core_->read_iobuffer_ = buf;
   return ERR_IO_PENDING;
 }
 
 int TCPClientSocketWin::Write(IOBuffer* buf,
                               int buf_len,
                               CompletionCallback* callback) {
+  DCHECK(CalledOnValidThread());
   DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(!waiting_write_);
   DCHECK(!write_callback_);
   DCHECK_GT(buf_len, 0);
   DCHECK(!core_->write_iobuffer_);
 
   static StatsCounter reads("tcp.writes");
   reads.Increment();
 
   core_->write_buffer_.len = buf_len;
@@ skipping 30 matching lines @@
       return MapWinsockError(os_error);
   }
   core_->WatchForWrite();
   waiting_write_ = true;
   write_callback_ = callback;
   core_->write_iobuffer_ = buf;
   return ERR_IO_PENDING;
 }
 
 bool TCPClientSocketWin::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: " << GetLastError();
   return rv == 0;
 }
 
 bool TCPClientSocketWin::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: " << GetLastError();
   return rv == 0;
 }
 
 int TCPClientSocketWin::CreateSocket(const struct addrinfo* ai) {
   socket_ = WSASocket(ai->ai_family, ai->ai_socktype, ai->ai_protocol, NULL, 0,
                       WSA_FLAG_OVERLAPPED);
   if (socket_ == INVALID_SOCKET) {
@@ skipping 158 matching lines @@
     } else {
       net_log_.AddEvent(NetLog::TYPE_SOCKET_BYTES_SENT,
                         new NetLogIntegerParameter("num_bytes", rv));
     }
   }
   core_->write_iobuffer_ = NULL;
   DoWriteCallback(rv);
 }
 
 }  // namespace net