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/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"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/it2me_host_authenticator_factory.h"
+#include "remoting/protocol/key_pair.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
 namespace remoting {
 
 namespace {
 
 // This is used for tagging system event logs.
 const char kApplicationName[] = "chromoting";
 
 const char* kAttrNameAccessCode = "accessCode";
@@ skipping 106 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_;
+  protocol::KeyPair 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 468 matching lines @@
   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_.Copy(), 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 774 matching lines @@
   std::string translation = StringFromNPVariant(np_result);
   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) {

[Wez, 2013/02/23 03:43:20]

Not strictly related to this CL, but... DoGenerateKeyPair really shouldn't be
passing references to ScopedRefNPObject to other threads, since NPObject
ref-counting isn't thread-safe.  We should save the completion callback object
to the HostNPScriptObject and then:

  callback = base::Bind(InvokeGenerateKeyPairCallback, WeakPtr(this));
  worker->PostTask(Bind(DoGenerateKeyPair, callback));

DoGenerateKeyPair then becomes a static.

[rmsousa, 2013/02/26 02:38:52]

There's already a TODO comment for it. I'll do that in a separate CL

-  HostKeyPair key_pair;
+  protocol::KeyPair key_pair;
   key_pair.Generate();
   InvokeGenerateKeyPairCallback(callback, key_pair.GetAsString(),
                                 key_pair.GetPublicKey());
 }
 
 void HostNPScriptObject::InvokeGenerateKeyPairCallback(
     const ScopedRefNPObject& callback,
     const std::string& private_key,
     const std::string& public_key) {
   if (!plugin_task_runner_->BelongsToCurrentThread()) {
@@ skipping 121 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