The continue window is owned by the desktop environment now.

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/strings/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_secret.h"
 #include "remoting/host/host_status_observer.h"
-#include "remoting/host/it2me_host_user_interface.h"
+#include "remoting/host/it2me_desktop_environment.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 "third_party/npapi/bindings/npruntime.h"
@@ skipping 120 matching lines @@
   XmppSignalStrategy::XmppServerConfig xmpp_server_config_;
   std::string directory_bot_jid_;
 
   State state_;
 
   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_;
 
   scoped_ptr<policy_hack::PolicyWatcher> policy_watcher_;
 
   // Host the current nat traversal policy setting.
   bool nat_traversal_enabled_;
 
@@ skipping 39 matching lines @@
     const UiStrings& ui_strings) {
   if (!host_context_->ui_task_runner()->BelongsToCurrentThread()) {
     DCHECK(plugin_task_runner_->BelongsToCurrentThread());
     host_context_->ui_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&It2MeImpl::Connect, this, uid, auth_token, auth_service,
                    ui_strings));
     return;
   }
 
-  desktop_environment_factory_.reset(new BasicDesktopEnvironmentFactory(
+  desktop_environment_factory_.reset(new It2MeDesktopEnvironmentFactory(
       host_context_->network_task_runner(),
       host_context_->input_task_runner(),
       host_context_->ui_task_runner(),
       ui_strings));
 
   // Start monitoring configured policies.
   policy_watcher_.reset(
       policy_hack::PolicyWatcher::Create(host_context_->network_task_runner()));
   policy_watcher_->StartWatching(
       base::Bind(&It2MeImpl::OnPolicyUpdate, this));
 
-  // The UserInterface object needs to be created on the UI thread.
-  it2me_host_user_interface_.reset(
-      new It2MeHostUserInterface(host_context_->network_task_runner(),
-                                 host_context_->ui_task_runner(), ui_strings));
-  it2me_host_user_interface_->Init();
-
   // Switch to the network thread to start the actual connection.
   host_context_->network_task_runner()->PostTask(
       FROM_HERE, base::Bind(
           &It2MeImpl::ReadPolicyAndConnect, this,
           uid, auth_token, auth_service));
 }
 
 void HostNPScriptObject::It2MeImpl::Disconnect() {
   if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
     DCHECK(plugin_task_runner_->BelongsToCurrentThread());
@@ skipping 135 matching lines @@
       new LogToServer(host_->AsWeakPtr(), ServerLogEntry::IT2ME,
                       signal_strategy_.get(), directory_bot_jid_));
 
   // 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());
 
-  // Create user interface.
-  it2me_host_user_interface_->Start(host_.get(),
-                                    base::Bind(&It2MeImpl::Disconnect, this));
-
   // Create event logger.
   host_event_logger_ =
       HostEventLogger::Create(host_->AsWeakPtr(), kApplicationName);
 
   // Connect signaling and start the host.
   signal_strategy_->Connect();
   host_->Start(uid);
 
   SetState(kRequestedAccessCode);
   return;
 }
 
 void HostNPScriptObject::It2MeImpl::OnShutdownFinished() {
   if (!host_context_->ui_task_runner()->BelongsToCurrentThread()) {
     host_context_->ui_task_runner()->PostTask(
         FROM_HERE, base::Bind(&It2MeImpl::OnShutdownFinished, this));
     return;
   }
 
   // Note that OnShutdownFinished() may be called more than once.
 
-  // 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();
 
   // 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 119 matching lines @@
   // When setting a host domain policy, force disconnect any existing session.
   if (!host_domain.empty() && IsConnected()) {
     Disconnect();
   }
 
   required_host_domain_ = host_domain;
 }
 
 HostNPScriptObject::It2MeImpl::~It2MeImpl() {
   // Check that resources that need to be torn down on the UI thread are gone.
-  DCHECK(!it2me_host_user_interface_.get());
   DCHECK(!desktop_environment_factory_.get());
   DCHECK(!policy_watcher_.get());
 }
 
 void HostNPScriptObject::It2MeImpl::SetState(State state) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   switch (state_) {
     case kDisconnected:
       DCHECK(state == kStarting ||
@@ skipping 86 matching lines @@
     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()),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       weak_ptr_(weak_factory_.GetWeakPtr()) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
+
+  // Set the thread task runner for the plugin thread so that timers and other
+  // code using |base::ThreadTaskRunnerHandle| could be used on the plugin
+  // thread.
+  //
+  // If component build is used, Chrome and the plugin may end up sharing base
+  // binary. This means that the instance of |base::ThreadTaskRunnerHandle|
+  // created by Chrome for the current thread is shared as well. This routinely
+  // happens in the development setting so the below check for
+  // |!base::ThreadTaskRunnerHandle::IsSet()| is a hack/workaround allowing this
+  // configuration to work. It lets the plugin to access Chrome's message loop
+  // directly via |base::ThreadTaskRunnerHandle|. This is safe as long as both
+  // Chrome and the plugin are built from the same version of the sources.
+  if (!base::ThreadTaskRunnerHandle::IsSet()) {
+    plugin_task_runner_handle_.reset(
+        new base::ThreadTaskRunnerHandle(plugin_task_runner_));
+  }
+
   ServiceUrls* service_urls = ServiceUrls::GetInstance();
   bool xmpp_server_valid = net::ParseHostAndPort(
       service_urls->xmpp_server_address(),
       &xmpp_server_config_.host, &xmpp_server_config_.port);
   // For the plugin, this is always the default address, which must be valid.
   DCHECK(xmpp_server_valid);
   xmpp_server_config_.use_tls = service_urls->xmpp_server_use_tls();
   directory_bot_jid_ = service_urls->directory_bot_jid();
 
   // Create worker thread for encryption key generation.
@@ skipping 893 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