Refactor ChannelAuthenticator so that it can be used with Authenticator.

remoting/protocol/jingle_stream_connector.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_stream_connector.h"
 
 #include "base/bind.h"
 #include "jingle/glue/channel_socket_adapter.h"
 #include "jingle/glue/pseudotcp_adapter.h"
 #include "net/base/cert_status_flags.h"
@@ skipping 54 matching lines @@
 JingleStreamConnector::JingleStreamConnector(
     JingleSession* session,
     const std::string& name,
     const Session::StreamChannelCallback& callback)
     : session_(session),
       name_(name),
       callback_(callback),
       initiator_(false),
       local_private_key_(NULL),
       raw_channel_(NULL),
-      ssl_client_socket_(NULL),
-      ssl_server_socket_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(tcp_connect_callback_(
           this, &JingleStreamConnector::OnTCPConnect)),
       ALLOW_THIS_IN_INITIALIZER_LIST(ssl_connect_callback_(
           this, &JingleStreamConnector::OnSSLConnect)) {
 }
 
 JingleStreamConnector::~JingleStreamConnector() {
 }
 
 void JingleStreamConnector::Connect(bool initiator,
@@ skipping 28 matching lines @@
   // error.
 
   // Set options for the TCP layer.
   jingle_glue::PseudoTcpAdapter* adapter =
       new jingle_glue::PseudoTcpAdapter(socket);
   adapter->SetAckDelay(kTcpAckDelayMilliseconds);
   adapter->SetNoDelay(true);
   adapter->SetReceiveBufferSize(kTcpReceiveBufferSize);
   adapter->SetSendBufferSize(kTcpSendBufferSize);
 
-  socket_.reset(adapter);
-  int result = socket_->Connect(&tcp_connect_callback_);
+  tcp_socket_.reset(adapter);
+  int result = tcp_socket_->Connect(&tcp_connect_callback_);
   if (result == net::ERR_IO_PENDING) {
     return true;
   } else if (result == net::OK) {
     tcp_connect_callback_.Run(result);
     return true;
   }
 
   return false;
 }
 
 bool JingleStreamConnector::EstablishSSLConnection() {
-  DCHECK(socket_->IsConnected());
+  DCHECK(tcp_socket_->IsConnected());
 
   int result;
   if (initiator_) {
     cert_verifier_.reset(new net::CertVerifier());
 
     // Create client SSL socket.
-    ssl_client_socket_ = CreateSSLClientSocket(
-        socket_.release(), remote_cert_, cert_verifier_.get());
-    socket_.reset(ssl_client_socket_);
+    net::SSLClientSocket* socket = CreateSSLClientSocket(
+        tcp_socket_.release(), remote_cert_, cert_verifier_.get());
+    socket_.reset(socket);
 
-    result = ssl_client_socket_->Connect(&ssl_connect_callback_);
+    result = socket->Connect(&ssl_connect_callback_);
   } else {
     scoped_refptr<net::X509Certificate> cert =
         net::X509Certificate::CreateFromBytes(
             local_cert_.data(), local_cert_.length());
     if (!cert) {
       LOG(ERROR) << "Failed to parse X509Certificate";
       return false;
     }
 
     // Create server SSL socket.
     net::SSLConfig ssl_config;
-    ssl_server_socket_ = net::CreateSSLServerSocket(
-        socket_.release(), cert, local_private_key_, ssl_config);
-    socket_.reset(ssl_server_socket_);
+    net::SSLServerSocket* socket = net::CreateSSLServerSocket(
+        tcp_socket_.release(), cert, local_private_key_, ssl_config);
+    socket_.reset(socket);
 
-    result = ssl_server_socket_->Handshake(&ssl_connect_callback_);
+    result = socket->Handshake(&ssl_connect_callback_);
   }
 
   if (result == net::ERR_IO_PENDING) {
     return true;
   } else if (result != net::OK) {
     LOG(ERROR) << "Failed to establish SSL connection";
     return false;
   }
 
   // Reach here if net::OK is received.
@@ skipping 22 matching lines @@
     NotifyError();
     return;
   }
 
   DCHECK(socket_->IsConnected());
   AuthenticateChannel();
 }
 
 void JingleStreamConnector::AuthenticateChannel() {
   if (initiator_) {
-    authenticator_.reset(new ClientChannelAuthenticator(ssl_client_socket_));
+    authenticator_.reset(
+        new ClientChannelAuthenticator(session_->shared_secret()));
   } else {
-    authenticator_.reset(new HostChannelAuthenticator(ssl_server_socket_));
+    authenticator_.reset(
+        new HostChannelAuthenticator(session_->shared_secret()));
   }
-
-  authenticator_->Authenticate(
-      session_->shared_secret(),
-      base::Bind(&JingleStreamConnector::OnAuthenticationDone,
-                 base::Unretained(this)));
+  authenticator_->Authenticate(socket_.get(), base::Bind(
+      &JingleStreamConnector::OnAuthenticationDone, base::Unretained(this)));
 }
 
 void JingleStreamConnector::OnAuthenticationDone(
     ChannelAuthenticator::Result result) {
   switch (result) {
     case ChannelAuthenticator::SUCCESS:
       NotifyDone(socket_.release());
       break;
 
     case ChannelAuthenticator::FAILURE:
       NotifyError();
       break;
   }
 }
 
 void JingleStreamConnector::NotifyDone(net::StreamSocket* socket) {
   session_->OnChannelConnectorFinished(name_, this);
   callback_.Run(socket);
   delete this;
 }
 
 void JingleStreamConnector::NotifyError() {
   socket_.reset();
   NotifyDone(NULL);
 }
 
 }  // namespace protocol
 }  // namespace remoting