Remove SocketWrapper to expose the threading issues it masks.

remoting/protocol/jingle_session.cc

 // Copyright (c) 2011 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 "remoting/protocol/jingle_session.h"
 
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "crypto/hmac.h"
 #include "crypto/rsa_private_key.h"
 #include "jingle/glue/channel_socket_adapter.h"
 #include "jingle/glue/pseudotcp_adapter.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service.h"
 #include "net/base/x509_certificate.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/ssl_server_socket.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/jingle_session_manager.h"
-#include "remoting/protocol/socket_wrapper.h"
 #include "third_party/libjingle/source/talk/base/thread.h"
 #include "third_party/libjingle/source/talk/p2p/base/session.h"
 #include "third_party/libjingle/source/talk/p2p/base/p2ptransportchannel.h"
 
 using cricket::BaseSession;
 
 namespace remoting {
 
 namespace protocol {
 
@@ skipping 146 matching lines @@
   DCHECK(CalledOnValidThread());
   return EncryptMasterKey(peer_public_key_, master_key_);
 }
 
 void JingleSession::CloseInternal(int result, bool failed) {
   DCHECK(CalledOnValidThread());
 
   if (!closed_ && !closing_) {
     closing_ = true;
 
-    if (control_channel_.get())
-      control_channel_->Close(result);
+    // Inform the StateChangeCallback, so calling code knows not to touch any
+    // channels.
+    if (failed)
+      SetState(FAILED);
+    else
+      SetState(CLOSED);
+
+    // Now tear down the remoting channel resources.
+    control_channel_.reset();
     control_socket_.reset();
     control_ssl_socket_.reset();
-    if (control_socket_wrapper_.get())
-      control_socket_wrapper_->Disconnect();
-
-    if (event_channel_.get())
-      event_channel_->Close(result);
+    event_channel_.reset();
     event_socket_.reset();
     event_ssl_socket_.reset();
-    if (event_socket_wrapper_.get())
-      event_socket_wrapper_->Disconnect();
-
-    if (video_channel_.get())
-      video_channel_->Close(result);
+    video_channel_.reset();
     video_socket_.reset();
     video_ssl_socket_.reset();
-    if (video_socket_wrapper_.get())
-      video_socket_wrapper_->Disconnect();
+    video_rtp_channel_.reset();
+    video_rtcp_channel_.reset();
 
-    if (video_rtp_channel_.get())
-      video_rtp_channel_->Close(result);
-    if (video_rtcp_channel_.get())
-      video_rtcp_channel_->Close(result);
-
+    // Tear down the cricket session, including the cricket transport channels.
     if (cricket_session_) {
       cricket_session_->Terminate();
       cricket_session_->SignalState.disconnect(this);
     }
 
-    if (failed)
-      SetState(FAILED);
-    else
-      SetState(CLOSED);
-
     closed_ = true;
   }
   cert_verifier_.reset();
 }
 
 bool JingleSession::HasSession(cricket::Session* cricket_session) {
   DCHECK(CalledOnValidThread());
   return cricket_session_ == cricket_session;
 }
 
@@ skipping 11 matching lines @@
 }
 
 void JingleSession::SetStateChangeCallback(StateChangeCallback* callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(callback);
   state_change_callback_.reset(callback);
 }
 
 net::Socket* JingleSession::control_channel() {
   DCHECK(CalledOnValidThread());
-  return control_socket_wrapper_.get();
+  return control_ssl_socket_.get();
 }
 
 net::Socket* JingleSession::event_channel() {
   DCHECK(CalledOnValidThread());
-  return event_socket_wrapper_.get();
+  return event_ssl_socket_.get();
 }
 
 // TODO(sergeyu): Remove this method after we switch to RTP.
 net::Socket* JingleSession::video_channel() {
   DCHECK(CalledOnValidThread());
-  return video_socket_wrapper_.get();
+  return video_ssl_socket_.get();
 }
 
 net::Socket* JingleSession::video_rtp_channel() {
   DCHECK(CalledOnValidThread());
   return video_rtp_channel_.get();
 }
 
 net::Socket* JingleSession::video_rtcp_channel() {
   DCHECK(CalledOnValidThread());
   return video_rtcp_channel_.get();
@@ skipping 366 matching lines @@
 void JingleSession::OnSSLConnect(int result) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(!closed_);
   if (result != net::OK) {
     LOG(ERROR) << "Error during SSL connection: " << result;
     CloseInternal(result, true);
     return;
   }
 
-  if (control_ssl_socket_.get() && control_ssl_socket_->IsConnected()) {
-    control_socket_wrapper_.reset(
-        new SocketWrapper(control_ssl_socket_.release()));
-  }
-  if (event_ssl_socket_.get() && event_ssl_socket_->IsConnected()) {
-    event_socket_wrapper_.reset(
-        new SocketWrapper(event_ssl_socket_.release()));
-  }
-  if (video_ssl_socket_.get() && video_ssl_socket_->IsConnected()) {
-    video_socket_wrapper_.reset(
-        new SocketWrapper(video_ssl_socket_.release()));
-  }
-
-  if (event_socket_wrapper_.get() &&
-      control_socket_wrapper_.get() &&
-      video_socket_wrapper_.get()) {
+  if (event_ssl_socket_.get() && event_ssl_socket_->IsConnected() &&
+      control_ssl_socket_.get() && control_ssl_socket_->IsConnected() &&
+      video_ssl_socket_.get() && video_ssl_socket_->IsConnected()) {
     SetState(CONNECTED);
   }
 }
 
 void JingleSession::SetState(State new_state) {
   DCHECK(CalledOnValidThread());
 
   if (new_state != state_) {
     DCHECK_NE(state_, CLOSED);
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (!closed_ && state_change_callback_.get())
       state_change_callback_->Run(new_state);
   }
 }
 
 }  // namespace protocol
 
 }  // namespace remoting