Move HostKeyPair into protocol::KeyPair.

remoting/protocol/ssl_hmac_channel_authenticator.cc

 // Copyright (c) 2012 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/ssl_hmac_channel_authenticator.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "crypto/secure_util.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.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/protocol/auth_util.h"
+#include "remoting/protocol/key_pair.h"
 
 namespace remoting {
 namespace protocol {
 
 // static
 scoped_ptr<SslHmacChannelAuthenticator>
 SslHmacChannelAuthenticator::CreateForClient(
       const std::string& remote_cert,
       const std::string& auth_key) {
   scoped_ptr<SslHmacChannelAuthenticator> result(
       new SslHmacChannelAuthenticator(auth_key));
   result->remote_cert_ = remote_cert;
   return result.Pass();
 }
 
 scoped_ptr<SslHmacChannelAuthenticator>
 SslHmacChannelAuthenticator::CreateForHost(
     const std::string& local_cert,
-    crypto::RSAPrivateKey* local_private_key,
+    scoped_ptr<KeyPair> key_pair,
     const std::string& auth_key) {
   scoped_ptr<SslHmacChannelAuthenticator> result(
       new SslHmacChannelAuthenticator(auth_key));
   result->local_cert_ = local_cert;
-  result->local_private_key_ = local_private_key;
+  result->key_pair_ = key_pair.Pass();
   return result.Pass();
 }
 
 SslHmacChannelAuthenticator::SslHmacChannelAuthenticator(
     const std::string& auth_key)
-    : auth_key_(auth_key),
-      local_private_key_(NULL) {
+    : auth_key_(auth_key) {
 }
 
 SslHmacChannelAuthenticator::~SslHmacChannelAuthenticator() {
 }
 
 void SslHmacChannelAuthenticator::SecureAndAuthenticate(
     scoped_ptr<net::StreamSocket> socket, const DoneCallback& done_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(socket->IsConnected());
 
   done_callback_ = done_callback;
 
   int result;
   if (is_ssl_server()) {
     scoped_refptr<net::X509Certificate> cert =
         net::X509Certificate::CreateFromBytes(
             local_cert_.data(), local_cert_.length());
     if (!cert) {
       LOG(ERROR) << "Failed to parse X509Certificate";
       NotifyError(net::ERR_FAILED);
       return;
     }
 
     net::SSLConfig ssl_config;
     net::SSLServerSocket* server_socket = net::CreateSSLServerSocket(
-        socket.release(), cert, local_private_key_, ssl_config);
+        socket.release(), cert, key_pair_->private_key(), ssl_config);
     socket_.reset(server_socket);
 
     result = server_socket->Handshake(base::Bind(
         &SslHmacChannelAuthenticator::OnConnected, base::Unretained(this)));
   } else {
     cert_verifier_.reset(net::CertVerifier::CreateDefault());
 
     net::SSLConfig::CertAndStatus cert_and_status;
     cert_and_status.cert_status = net::CERT_STATUS_AUTHORITY_INVALID;
     cert_and_status.der_cert = remote_cert_;
@@ skipping 19 matching lines @@
                    base::Unretained(this)));
   }
 
   if (result == net::ERR_IO_PENDING)
     return;
 
   OnConnected(result);
 }
 
 bool SslHmacChannelAuthenticator::is_ssl_server() {
-  return local_private_key_ != NULL;
+  return key_pair_.get() != NULL;
 }
 
 void SslHmacChannelAuthenticator::OnConnected(int result) {
   if (result != net::OK) {
     LOG(WARNING) << "Failed to establish SSL connection";
     NotifyError(result);
     return;
   }
 
   // Generate authentication digest to write to the socket.
@@ skipping 130 matching lines @@
   }
 }
 
 void SslHmacChannelAuthenticator::NotifyError(int error) {
   done_callback_.Run(static_cast<net::Error>(error),
                      scoped_ptr<net::StreamSocket>(NULL));
 }
 
 }  // namespace protocol
 }  // namespace remoting