Use AutoThread in ChromotingHostContext & NPAPI plugin.

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/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/auto_thread_task_runner.h"
 #include "remoting/base/auth_token_util.h"
+#include "remoting/base/auto_thread.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment_factory.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"
@@ skipping 629 matching lines @@
 HostNPScriptObject::HostNPScriptObject(
     NPP plugin,
     NPObject* parent,
     scoped_refptr<AutoThreadTaskRunner> plugin_task_runner)
     : plugin_(plugin),
       parent_(parent),
       plugin_task_runner_(plugin_task_runner),
       am_currently_logging_(false),
       state_(kDisconnected),
       daemon_controller_(DaemonController::Create()),
-      worker_thread_("RemotingHostPlugin"),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       weak_ptr_(weak_factory_.GetWeakPtr()) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
-  worker_thread_.Start();
+  // Create worker thread for encryption key generation.
+  worker_thread_ = AutoThread::Create("ChromotingWorkerThread",
+                                      plugin_task_runner_);
 }
 
 HostNPScriptObject::~HostNPScriptObject() {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   HostLogHandler::UnregisterLoggingScriptObject(this);
 
   // Stop the It2Me host if the caller forgot to.
   if (it2me_impl_.get()) {
     it2me_impl_->Disconnect();
     it2me_impl_ = NULL;
   }
-
-  // Stop the worker thread.
-  worker_thread_.Stop();
 }
 
 bool HostNPScriptObject::HasMethod(const std::string& method_name) {
   VLOG(2) << "HasMethod " << method_name;
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   return (method_name == kFuncNameConnect ||
           method_name == kFuncNameDisconnect ||
           method_name == kFuncNameLocalize ||
           method_name == kFuncNameGetHostName ||
           method_name == kFuncNameGetPinHash ||
@@ skipping 248 matching lines @@
   std::string auth_token;
   std::string auth_service;
   ParseAuthTokenWithService(auth_service_with_token, &auth_token,
                             &auth_service);
   if (auth_token.empty()) {
     SetException("connect: auth_service_with_token argument has empty token");
     return false;
   }
 
   // Create threads for the Chromoting host & desktop environment to use.
-  scoped_ptr<ChromotingHostContext> host_context(
-      new ChromotingHostContext(plugin_task_runner_));
-  if (!host_context->Start()) {
+  scoped_ptr<ChromotingHostContext> host_context =
+    ChromotingHostContext::Create(plugin_task_runner_);
+  if (host_context) {
     SetException("connect: failed to start threads");
     return false;
   }
 
   // Create the It2Me host implementation and start connecting.
   it2me_impl_ = new It2MeImpl(
       host_context.Pass(), plugin_task_runner_, weak_ptr_, ui_strings_);
   it2me_impl_->Connect(uid, auth_token, auth_service);
 
   return true;
@@ skipping 82 matching lines @@
 
   ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
   if (!callback_obj.get()) {
     SetException("generateKeyPair: invalid callback parameter");
     return false;
   }
 
   // TODO(wez): HostNPScriptObject needn't be touched on worker
   // thread, so make DoGenerateKeyPair static and pass it a callback
   // to run (crbug.com/156257).
-  worker_thread_.message_loop_proxy()->PostTask(
+  worker_thread_->PostTask(
       FROM_HERE, base::Bind(&HostNPScriptObject::DoGenerateKeyPair,
                             base::Unretained(this), callback_obj));
   return true;
 }
 
 bool HostNPScriptObject::UpdateDaemonConfig(const NPVariant* args,
                                             uint32_t arg_count,
                                             NPVariant* result) {
   if (arg_count != 2) {
     SetException("updateDaemonConfig: bad number of arguments");
@@ skipping 419 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