Move HostKeyPair into protocol::KeyPair.

remoting/protocol/v2_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/v2_authenticator.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
-#include "crypto/rsa_private_key.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/ssl_hmac_channel_authenticator.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using crypto::P224EncryptedKeyExchange;
 
 #if defined(_WIN32) && defined(GetMessage)
 #undef GetMessage
 #endif
 
@@ skipping 18 matching lines @@
 scoped_ptr<Authenticator> V2Authenticator::CreateForClient(
     const std::string& shared_secret,
     Authenticator::State initial_state) {
   return scoped_ptr<Authenticator>(new V2Authenticator(
       P224EncryptedKeyExchange::kPeerTypeClient, shared_secret, initial_state));
 }
 
 // static
 scoped_ptr<Authenticator> V2Authenticator::CreateForHost(
     const std::string& local_cert,
-    const crypto::RSAPrivateKey& local_private_key,
+    scoped_ptr<KeyPair> key_pair,
     const std::string& shared_secret,
     Authenticator::State initial_state) {
   scoped_ptr<V2Authenticator> result(new V2Authenticator(
       P224EncryptedKeyExchange::kPeerTypeServer, shared_secret, initial_state));
   result->local_cert_ = local_cert;
-  result->local_private_key_.reset(local_private_key.Copy());
+  result->key_pair_ = key_pair.Pass();
   return scoped_ptr<Authenticator>(result.Pass());
 }
 
 V2Authenticator::V2Authenticator(
     crypto::P224EncryptedKeyExchange::PeerType type,
     const std::string& shared_secret,
     Authenticator::State initial_state)
     : certificate_sent_(false),
       key_exchange_impl_(type, shared_secret),
       state_(initial_state),
@@ skipping 115 matching lines @@
 }
 
 scoped_ptr<ChannelAuthenticator>
 V2Authenticator::CreateChannelAuthenticator() const {
   DCHECK_EQ(state(), ACCEPTED);
   CHECK(!auth_key_.empty());
 
   if (is_host_side()) {
     return scoped_ptr<ChannelAuthenticator>(
         SslHmacChannelAuthenticator::CreateForHost(
-            local_cert_, local_private_key_.get(), auth_key_).Pass());
+            local_cert_, key_pair_->Copy(), auth_key_).Pass());
   } else {
     return scoped_ptr<ChannelAuthenticator>(
         SslHmacChannelAuthenticator::CreateForClient(
             remote_cert_, auth_key_).Pass());
   }
 }
 
 bool V2Authenticator::is_host_side() const {
-  return local_private_key_.get() != NULL;
+  return key_pair_.get() != NULL;
 }
 
 }  // namespace protocol
 }  // namespace remoting