[Chromoting] Refactoring DesktopEnvironment and moving screen/audio recorders to ClientSession.

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/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
-#include "remoting/host/desktop_environment.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/it2me_host_user_interface.h"
 #include "remoting/host/network_settings.h"
 #include "remoting/host/pin_hash.h"
 #include "remoting/host/plugin/daemon_controller.h"
 #include "remoting/host/plugin/host_log_handler.h"
 #include "remoting/host/policy_hack/policy_watcher.h"
@@ skipping 53 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),
       nat_traversal_enabled_(false),
       policy_received_(false),
       daemon_controller_(DaemonController::Create()),
       worker_thread_("RemotingHostPlugin") {
   worker_thread_.Start();
 }
 
 HostNPScriptObject::~HostNPScriptObject() {
@@ skipping 390 matching lines @@
             &HostNPScriptObject::ReadPolicyAndConnect, base::Unretained(this),
             uid, auth_token, auth_service));
     return;
   }
 
   SetState(kStarting);
 
   // Only proceed to FinishConnect() if at least one policy update has been
   // received.
   if (policy_received_) {
-    FinishConnectMainThread(uid, auth_token, auth_service);
+    FinishConnect(uid, auth_token, auth_service);
   } else {
     // Otherwise, create the policy watcher, and thunk the connect.
     pending_connect_ =
-        base::Bind(&HostNPScriptObject::FinishConnectMainThread,
+        base::Bind(&HostNPScriptObject::FinishConnect,
                    base::Unretained(this), uid, auth_token, auth_service);
   }
 }
 
-void HostNPScriptObject::FinishConnectMainThread(
-    const std::string& uid,
-    const std::string& auth_token,
-    const std::string& auth_service) {
-  if (!host_context_->capture_task_runner()->BelongsToCurrentThread()) {
-    host_context_->capture_task_runner()->PostTask(FROM_HERE, base::Bind(
-        &HostNPScriptObject::FinishConnectMainThread, base::Unretained(this),
-        uid, auth_token, auth_service));
-    return;
-  }
-
-  // DesktopEnvironment must be initialized on the capture thread.
-  //
-  // TODO(sergeyu): Fix DesktopEnvironment so that it can be created
-  // on either the UI or the network thread so that we can avoid
-  // jumping to the main thread here.
-  desktop_environment_ = DesktopEnvironment::Create(host_context_.get());
-
-  FinishConnectNetworkThread(uid, auth_token, auth_service);
-}
-
-void HostNPScriptObject::FinishConnectNetworkThread(
+void HostNPScriptObject::FinishConnect(
     const std::string& uid,
     const std::string& auth_token,
     const std::string& auth_service) {
   if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
     host_context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
-        &HostNPScriptObject::FinishConnectNetworkThread, base::Unretained(this),
+        &HostNPScriptObject::FinishConnect, base::Unretained(this),
         uid, auth_token, auth_service));
     return;
   }
 
   if (state_ != kStarting) {
     // Host has been stopped while we were fetching policy.
     return;
   }
 
   // Check the host domain policy.
   if (!required_host_domain_.empty() &&
       !EndsWith(uid, std::string("@") + required_host_domain_, false)) {
     SetState(kError);
     return;
   }
 
-  // Verify that DesktopEnvironment has been created.
-  if (desktop_environment_.get() == NULL) {
-    SetState(kError);
-    return;
-  }
-
   // Generate a key pair for the Host to use.
   // TODO(wez): Move this to the worker thread.
   host_key_pair_.Generate();
 
   // Create XMPP connection.
   scoped_ptr<SignalStrategy> signal_strategy(
       new XmppSignalStrategy(host_context_->url_request_context_getter(),
                              uid, auth_token, auth_service));
 
   // Request registration of the host for support.
   scoped_ptr<RegisterSupportHostRequest> register_request(
       new RegisterSupportHostRequest(
           signal_strategy.get(), &host_key_pair_,
           base::Bind(&HostNPScriptObject::OnReceivedSupportID,
                      base::Unretained(this))));
 
   // Beyond this point nothing can fail, so save the config and request.
   signal_strategy_.reset(signal_strategy.release());
   register_request_.reset(register_request.release());
 
   // Create the Host.
   LOG(INFO) << "NAT state: " << nat_traversal_enabled_;
   host_ = new ChromotingHost(
-      host_context_.get(), signal_strategy_.get(), desktop_environment_.get(),
+      host_context_.get(), signal_strategy_.get(),
+      desktop_environment_factory_.get(),
       CreateHostSessionManager(
           NetworkSettings(nat_traversal_enabled_ ?
                           NetworkSettings::NAT_TRAVERSAL_ENABLED :
                           NetworkSettings::NAT_TRAVERSAL_DISABLED),
           host_context_->url_request_context_getter()));
   host_->AddStatusObserver(this);
   log_to_server_.reset(
       new LogToServer(host_, ServerLogEntry::IT2ME, signal_strategy_.get()));
   base::Closure disconnect_callback = base::Bind(
       &ChromotingHost::Shutdown, base::Unretained(host_.get()),
@@ skipping 274 matching lines @@
         FROM_HERE, base::Bind(&HostNPScriptObject::DisconnectInternal,
                               base::Unretained(this)));
     return;
   }
 
   switch (state_) {
     case kDisconnected:
       return;
 
     case kStarting:
-      desktop_environment_.reset();
       SetState(kDisconnecting);
       SetState(kDisconnected);
       return;
 
     case kDisconnecting:
       return;
 
     default:
       SetState(kDisconnecting);
 
       if (!host_) {
         OnShutdownFinished();
         return;
       }
       // ChromotingHost::Shutdown() may destroy SignalStrategy
       // synchronously, but SignalStrategy::Listener handlers are not
       // allowed to destroy SignalStrategy, so post task to call
       // Shutdown() later.
       host_context_->network_task_runner()->PostTask(
           FROM_HERE, base::Bind(
               &ChromotingHost::Shutdown, host_,
               base::Bind(&HostNPScriptObject::OnShutdownFinished,
                          base::Unretained(this))));
       return;
   }
 }
 
 void HostNPScriptObject::OnShutdownFinished() {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
-
-  desktop_environment_.reset();
 }
 
 void HostNPScriptObject::OnPolicyUpdate(
     scoped_ptr<base::DictionaryValue> policies) {
   if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
     host_context_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostNPScriptObject::OnPolicyUpdate,
                    base::Unretained(this), base::Passed(&policies)));
     return;
@@ skipping 371 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