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 76 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),
       disconnected_event_(true, false),
       stopped_event_(true, false),
       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_);
 
   HostLogHandler::UnregisterLoggingScriptObject(this);
 
   // Stop the message loop. Any attempt to post a task to
-  // |context_.ui_task_runner()| will result in a CHECK() after this point.
+  // |host_context_.ui_task_runner()| will result in a CHECK() after this point.
   // TODO(alexeypa): Enable posting messages to |plugin_task_runner_| during
   // shutdown to avoid this hack.
   plugin_task_runner_->Detach();
 
   // Stop listening for policy updates.
   if (policy_watcher_.get()) {
     base::WaitableEvent policy_watcher_stopped_(true, false);
     policy_watcher_->StopWatching(&policy_watcher_stopped_);
     policy_watcher_stopped_.Wait();
     policy_watcher_.reset();
@@ skipping 29 matching lines @@
     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.
   host_context_.reset(new ChromotingHostContext(new AutoThreadTaskRunner(
       plugin_task_runner_,
       base::Bind(&base::WaitableEvent::Signal,
                  base::Unretained(&stopped_event_)))));
   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 718 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