Don't check type of thread in socket adapters.

BUG=None
TEST=Unittests

Review URL: http://codereview.chromium.org/6771033

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@80116 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 43 insertions, 14 deletions

diff --git a/jingle/glue/channel_socket_adapter.cc b/jingle/glue/channel_socket_adapter.cc
index b6866ca..1cdcf01 100644
--- a/jingle/glue/channel_socket_adapter.cc
+++ b/jingle/glue/channel_socket_adapter.cc
@@ -16,11 +16,11 @@ namespace jingle_glue {
 
 TransportChannelSocketAdapter::TransportChannelSocketAdapter(
     cricket::TransportChannel* channel)
-    : channel_(channel),
+    : message_loop_(MessageLoop::current()),
+      channel_(channel),
       read_pending_(false),
       write_pending_(false),
       closed_error_code_(net::OK) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
   DCHECK(channel_);
 
   channel_->SignalReadPacket.connect(
@@ -36,7 +36,7 @@ TransportChannelSocketAdapter::~TransportChannelSocketAdapter() {
 
 int TransportChannelSocketAdapter::Read(
     net::IOBuffer* buf, int buffer_size, net::CompletionCallback* callback) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(buf);
   CHECK(!read_pending_);
 
@@ -55,7 +55,7 @@ int TransportChannelSocketAdapter::Read(
 
 int TransportChannelSocketAdapter::Write(
     net::IOBuffer* buffer, int buffer_size, net::CompletionCallback* callback) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(buffer);
   CHECK(!write_pending_);
 
@@ -78,17 +78,19 @@ int TransportChannelSocketAdapter::Write(
 }
 
 bool TransportChannelSocketAdapter::SetReceiveBufferSize(int32 size) {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   NOTIMPLEMENTED();
   return false;
 }
 
 bool TransportChannelSocketAdapter::SetSendBufferSize(int32 size) {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   NOTIMPLEMENTED();
   return false;
 }
 
 void TransportChannelSocketAdapter::Close(int error_code) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (!channel_)  // Already closed.
     return;
@@ -116,7 +118,7 @@ void TransportChannelSocketAdapter::Close(int error_code) {
 
 void TransportChannelSocketAdapter::OnNewPacket(
     cricket::TransportChannel* channel, const char* data, size_t data_size) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_EQ(channel, channel_);
   if (read_pending_) {
     DCHECK(read_buffer_);
@@ -143,7 +145,7 @@ void TransportChannelSocketAdapter::OnNewPacket(
 
 void TransportChannelSocketAdapter::OnWritableState(
     cricket::TransportChannel* channel) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   // Try to send the packet if there is a pending write.
   if (write_pending_) {
     int result = channel_->SendPacket(write_buffer_->data(),
@@ -162,7 +164,7 @@ void TransportChannelSocketAdapter::OnWritableState(
 
 void TransportChannelSocketAdapter::OnChannelDestroyed(
     cricket::TransportChannel* channel) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_EQ(channel, channel_);
   Close(net::ERR_CONNECTION_ABORTED);
 }
diff --git a/jingle/glue/channel_socket_adapter.h b/jingle/glue/channel_socket_adapter.h
index 1df852d..81731e7 100644
--- a/jingle/glue/channel_socket_adapter.h
+++ b/jingle/glue/channel_socket_adapter.h
@@ -9,6 +9,8 @@
 #include "third_party/libjingle/source/talk/base/socketaddress.h"
 #include "third_party/libjingle/source/talk/base/sigslot.h"
 
+class MessageLoop;
+
 namespace cricket {
 class TransportChannel;
 }  // namespace cricket
@@ -45,6 +47,8 @@ class TransportChannelSocketAdapter : public net::Socket,
   void OnWritableState(cricket::TransportChannel* channel);
   void OnChannelDestroyed(cricket::TransportChannel* channel);
 
+  MessageLoop* message_loop_;
+
   cricket::TransportChannel* channel_;
 
   bool read_pending_;
diff --git a/jingle/glue/stream_socket_adapter.cc b/jingle/glue/stream_socket_adapter.cc
index 0cf45fb..ea38aef 100644
--- a/jingle/glue/stream_socket_adapter.cc
+++ b/jingle/glue/stream_socket_adapter.cc
@@ -14,11 +14,11 @@
 namespace jingle_glue {
 
 StreamSocketAdapter::StreamSocketAdapter(talk_base::StreamInterface* stream)
-    : stream_(stream),
+    : message_loop_(MessageLoop::current()),
+      stream_(stream),
       read_pending_(false),
       write_pending_(false),
       closed_error_code_(net::OK) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
   DCHECK(stream);
   stream_->SignalEvent.connect(this, &StreamSocketAdapter::OnStreamEvent);
 }
@@ -27,21 +27,27 @@ StreamSocketAdapter::~StreamSocketAdapter() {
 }
 
 int StreamSocketAdapter::Connect(net::CompletionCallback* callback) {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   return net::OK;
 }
 
 void StreamSocketAdapter::Disconnect() {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
 }
 
 bool StreamSocketAdapter::IsConnected() const {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   return true;
 }
 
 bool StreamSocketAdapter::IsConnectedAndIdle() const {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   return true;
 }
 
 int StreamSocketAdapter::GetPeerAddress(net::AddressList* address) const {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+
   // We actually don't know the peer address. Returning so the upper layers
   // won't complain.
   net::IPAddressNumber ip_address(4);
@@ -50,26 +56,31 @@ int StreamSocketAdapter::GetPeerAddress(net::AddressList* address) const {
 }
 
 const net::BoundNetLog& StreamSocketAdapter::NetLog() const {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   return net_log_;
 }
 
 void StreamSocketAdapter::SetSubresourceSpeculation() {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
 }
 
 void StreamSocketAdapter::SetOmniboxSpeculation() {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
 }
 
 bool StreamSocketAdapter::WasEverUsed() const {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   return true;
 }
 
 bool StreamSocketAdapter::UsingTCPFastOpen() const {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   return false;
 }
 
 int StreamSocketAdapter::Read(
     net::IOBuffer* buffer, int buffer_size, net::CompletionCallback* callback) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(buffer);
   CHECK(!read_pending_);
 
@@ -93,7 +104,7 @@ int StreamSocketAdapter::Read(
 
 int StreamSocketAdapter::Write(
     net::IOBuffer* buffer, int buffer_size, net::CompletionCallback* callback) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(buffer);
   CHECK(!write_pending_);
 
@@ -127,7 +138,7 @@ bool StreamSocketAdapter::SetSendBufferSize(int32 size) {
 }
 
 void StreamSocketAdapter::Close(int error_code) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (!stream_.get())  // Already closed.
     return;
@@ -155,7 +166,7 @@ void StreamSocketAdapter::Close(int error_code) {
 
 void StreamSocketAdapter::OnStreamEvent(
     talk_base::StreamInterface* stream, int events, int error) {
-  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (events & talk_base::SE_WRITE)
     DoWrite();
@@ -165,6 +176,8 @@ void StreamSocketAdapter::OnStreamEvent(
 }
 
 void StreamSocketAdapter::DoWrite() {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+
   // Write if there is a pending read.
   if (write_buffer_) {
     int result = WriteStream(write_buffer_, write_buffer_size_);
@@ -178,6 +191,8 @@ void StreamSocketAdapter::DoWrite() {
 }
 
 void StreamSocketAdapter::DoRead() {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+
   // Read if there is a pending read.
   if (read_pending_) {
     int result = ReadStream(read_buffer_, read_buffer_size_);
@@ -191,6 +206,8 @@ void StreamSocketAdapter::DoRead() {
 }
 
 int StreamSocketAdapter::ReadStream(net::IOBuffer* buffer, int buffer_size) {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+
   size_t bytes_read;
   int error;
   talk_base::StreamResult result = stream_->Read(
@@ -213,6 +230,8 @@ int StreamSocketAdapter::ReadStream(net::IOBuffer* buffer, int buffer_size) {
 }
 
 int StreamSocketAdapter::WriteStream(net::IOBuffer* buffer, int buffer_size) {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+
   size_t bytes_written;
   int error;
   talk_base::StreamResult result = stream_->Write(
diff --git a/jingle/glue/stream_socket_adapter.h b/jingle/glue/stream_socket_adapter.h
index aa5fb5d..910aa57 100644
--- a/jingle/glue/stream_socket_adapter.h
+++ b/jingle/glue/stream_socket_adapter.h
@@ -10,6 +10,8 @@
 #include "net/socket/client_socket.h"
 #include "third_party/libjingle/source/talk/base/sigslot.h"
 
+class MessageLoop;
+
 namespace talk_base {
 class StreamInterface;
 }  // namespace talk_base
@@ -61,6 +63,8 @@ class StreamSocketAdapter : public net::ClientSocket,
   int ReadStream(net::IOBuffer* buffer, int buffer_size);
   int WriteStream(net::IOBuffer* buffer, int buffer_size);
 
+  MessageLoop* message_loop_;
+
   scoped_ptr<talk_base::StreamInterface> stream_;
 
   bool read_pending_;