Move HostKeyPair into protocol::KeyPair.

remoting/host/plugin/host_script_object.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/host/plugin/host_script_object.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/sys_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "net/base/net_util.h"
 #include "remoting/base/auth_token_util.h"
 #include "remoting/base/auto_thread.h"
+#include "remoting/base/rsa_key_pair.h"
 #include "remoting/host/basic_desktop_environment.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_event_logger.h"
-#include "remoting/host/host_key_pair.h"
 #include "remoting/host/host_secret.h"
 #include "remoting/host/host_status_observer.h"
 #include "remoting/host/it2me_host_user_interface.h"
 #include "remoting/host/network_settings.h"
 #include "remoting/host/pin_hash.h"
 #include "remoting/host/plugin/host_log_handler.h"
 #include "remoting/host/policy_hack/policy_watcher.h"
 #include "remoting/host/register_support_host_request.h"
 #include "remoting/host/service_urls.h"
 #include "remoting/host/session_manager_factory.h"
@@ skipping 118 matching lines @@
 
   // Caller supplied fields.
   scoped_ptr<ChromotingHostContext> host_context_;
   scoped_refptr<base::SingleThreadTaskRunner> plugin_task_runner_;
   base::WeakPtr<HostNPScriptObject> script_object_;
   XmppSignalStrategy::XmppServerConfig xmpp_server_config_;
   std::string directory_bot_jid_;
 
   State state_;
 
-  HostKeyPair host_key_pair_;
+  scoped_refptr<RsaKeyPair> host_key_pair_;
   scoped_ptr<SignalStrategy> signal_strategy_;
   scoped_ptr<RegisterSupportHostRequest> register_request_;
   scoped_ptr<LogToServer> log_to_server_;
   scoped_ptr<DesktopEnvironmentFactory> desktop_environment_factory_;
   scoped_ptr<It2MeHostUserInterface> it2me_host_user_interface_;
   scoped_ptr<HostEventLogger> host_event_logger_;
 
   scoped_refptr<ChromotingHost> host_;
   int failed_login_attempts_;
 
@@ skipping 161 matching lines @@
 
   // Check the host domain policy.
   if (!required_host_domain_.empty() &&
       !EndsWith(uid, std::string("@") + required_host_domain_, false)) {
     SetState(kInvalidDomainError);
     return;
   }
 
   // Generate a key pair for the Host to use.
   // TODO(wez): Move this to the worker thread.
-  host_key_pair_.Generate();
+  host_key_pair_ = RsaKeyPair::Generate();
 
   // Create XMPP connection.
   scoped_ptr<SignalStrategy> signal_strategy(
       new XmppSignalStrategy(host_context_->url_request_context_getter(),
                              uid, auth_token, auth_service,
                              xmpp_server_config_));
 
   // Request registration of the host for support.
   scoped_ptr<RegisterSupportHostRequest> register_request(
       new RegisterSupportHostRequest(
-          signal_strategy.get(), &host_key_pair_, directory_bot_jid_,
+          signal_strategy.get(), host_key_pair_, directory_bot_jid_,
           base::Bind(&It2MeImpl::OnReceivedSupportID,
                      base::Unretained(this))));
 
   // Beyond this point nothing can fail, so save the config and request.
   signal_strategy_ = signal_strategy.Pass();
   register_request_ = register_request.Pass();
 
   // If NAT traversal is off then limit port range to allow firewall pin-holing.
   LOG(INFO) << "NAT state: " << nat_traversal_enabled_;
   NetworkSettings network_settings(
@@ skipping 266 matching lines @@
 
   if (!success) {
     SetState(kError);
     Disconnect();
     return;
   }
 
   std::string host_secret = GenerateSupportHostSecret();
   std::string access_code = support_id + host_secret;
 
-  std::string local_certificate = host_key_pair_.GenerateCertificate();
+  std::string local_certificate = host_key_pair_->GenerateCertificate();
   if (local_certificate.empty()) {
     LOG(ERROR) << "Failed to generate host certificate.";
     SetState(kError);
     Disconnect();
     return;
   }
 
   scoped_ptr<protocol::AuthenticatorFactory> factory(
       new protocol::It2MeHostAuthenticatorFactory(
-          local_certificate, *host_key_pair_.private_key(), access_code));
+          local_certificate, host_key_pair_, access_code));
   host_->SetAuthenticatorFactory(factory.Pass());
 
   // Pass the Access Code to the script object before changing state.
   plugin_task_runner_->PostTask(
       FROM_HERE, base::Bind(&HostNPScriptObject::StoreAccessCode,
                             script_object_, access_code, lifetime));
 
   SetState(kReceivedAccessCode);
 }
 
@@ skipping 775 matching lines @@
   g_npnetscape_funcs->releasevariantvalue(&np_result);
   if (translation.empty()) {
     LOG(ERROR) << "Missing translation for " << tag;
     return false;
   }
   *result = UTF8ToUTF16(translation);
   return true;
 }
 
 void HostNPScriptObject::DoGenerateKeyPair(const ScopedRefNPObject& callback) {
-  HostKeyPair key_pair;
-  key_pair.Generate();
-  InvokeGenerateKeyPairCallback(callback, key_pair.GetAsString(),
-                                key_pair.GetPublicKey());
+  scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::Generate();
+  InvokeGenerateKeyPairCallback(callback, key_pair->ToString(),
+                                key_pair->GetPublicKey());
 }
 
 void HostNPScriptObject::InvokeGenerateKeyPairCallback(
     const ScopedRefNPObject& callback,
     const std::string& private_key,
     const std::string& public_key) {
   if (!plugin_task_runner_->BelongsToCurrentThread()) {
     plugin_task_runner_->PostTask(
         FROM_HERE, base::Bind(
             &HostNPScriptObject::InvokeGenerateKeyPairCallback,
@@ skipping 118 matching lines @@
 }
 
 void HostNPScriptObject::SetException(const std::string& exception_string) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   g_npnetscape_funcs->setexception(parent_, exception_string.c_str());
   LOG(INFO) << exception_string;
 }
 
 }  // namespace remoting