Fix ChromotingHost and DesktopEnvironmentFactory references to TaskRunners.

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"
@@ skipping 75 matching lines @@
     NPP plugin,
     NPObject* parent,
     PluginThreadTaskRunner::Delegate* plugin_thread_delegate)
     : plugin_(plugin),
       parent_(parent),
       am_currently_logging_(false),
       state_(kDisconnected),
       np_thread_id_(base::PlatformThread::CurrentId()),
       plugin_task_runner_(
           new PluginThreadTaskRunner(plugin_thread_delegate)),
-      desktop_environment_factory_(new DesktopEnvironmentFactory()),
       failed_login_attempts_(0),
       nat_traversal_enabled_(false),
       policy_received_(false),
       daemon_controller_(DaemonController::Create()),
       worker_thread_("RemotingHostPlugin") {
   worker_thread_.Start();
 }
 
 HostNPScriptObject::~HostNPScriptObject() {
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
@@ skipping 20 matching lines @@
 
   // Stop all threads.
   host_context_.reset();
   worker_thread_.Stop();
 }
 
 bool HostNPScriptObject::Init() {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   VLOG(2) << "Init";
 
+  // Create threads for the Chromoting host & desktop environment to use.
   scoped_refptr<AutoThreadTaskRunner> auto_plugin_task_runner =
       new AutoThreadTaskRunner(plugin_task_runner_,
                                base::Bind(&PluginThreadTaskRunner::Quit,
                                           plugin_task_runner_));
   host_context_.reset(new ChromotingHostContext(auto_plugin_task_runner));
   auto_plugin_task_runner = NULL;
   if (!host_context_->Start()) {
     host_context_.reset();
     return false;
   }
 
+  // Create the desktop environment factory.
+  desktop_environment_factory_.reset(new DesktopEnvironmentFactory(
+      host_context_->input_task_runner(), host_context_->ui_task_runner()));
+
+  // Start monitoring configured policies.
   policy_watcher_.reset(
       policy_hack::PolicyWatcher::Create(host_context_->network_task_runner()));
   policy_watcher_->StartWatching(
       base::Bind(&HostNPScriptObject::OnPolicyUpdate,
                  base::Unretained(this)));
   return true;
 }
 
 bool HostNPScriptObject::HasMethod(const std::string& method_name) {
   VLOG(2) << "HasMethod " << method_name;
@@ skipping 396 matching lines @@
      nat_traversal_enabled_ ?
      NetworkSettings::NAT_TRAVERSAL_ENABLED :
      NetworkSettings::NAT_TRAVERSAL_DISABLED);
   if (!nat_traversal_enabled_) {
     network_settings.min_port = NetworkSettings::kDefaultMinPort;
     network_settings.max_port = NetworkSettings::kDefaultMaxPort;
   }
 
   // Create the host.
   host_ = new ChromotingHost(
-      host_context_.get(), signal_strategy_.get(),
+      signal_strategy_.get(),
       desktop_environment_factory_.get(),
       CreateHostSessionManager(network_settings,
-                               host_context_->url_request_context_getter()));
+                               host_context_->url_request_context_getter()),
+      host_context_->capture_task_runner(),
+      host_context_->encode_task_runner(),
+      host_context_->network_task_runner());
   host_->AddStatusObserver(this);
   log_to_server_.reset(
       new LogToServer(host_, ServerLogEntry::IT2ME, signal_strategy_.get()));
 
   // Disable audio by default.
   // TODO(sergeyu): Add UI to enable it.
   scoped_ptr<protocol::CandidateSessionConfig> protocol_config =
       protocol::CandidateSessionConfig::CreateDefault();
   protocol::CandidateSessionConfig::DisableAudioChannel(protocol_config.get());
   host_->set_protocol_config(protocol_config.Pass());
@@ skipping 329 matching lines @@
     return;
   }
 
   // UI needs to be shut down on the UI thread before we destroy the
   // host context (because it depends on the context object), but
   // only after the host has been shut down (becase the UI object is
   // registered as status observer for the host, and we can't
   // unregister it from this thread).
   it2me_host_user_interface_.reset();
 
+  // Destroy the DesktopEnvironmentFactory, to free thread references.
+  desktop_environment_factory_.reset();
+
   // Release the context's TaskRunner references for the threads, so they can
   // exit when no objects need them.
   host_context_->ReleaseTaskRunners();
 }
 
 void HostNPScriptObject::OnPolicyUpdate(
     scoped_ptr<base::DictionaryValue> policies) {
   if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
     host_context_->network_task_runner()->PostTask(
         FROM_HERE,
@@ skipping 393 matching lines @@
   return is_good;
 }
 
 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