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

remoting/host/simple_host_process.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.
 //
 // This is an application of a minimal host process in a Chromoting
 // system. It serves the purpose of gluing different pieces together
 // to make a functional host process for testing.
 //
 // It peforms the following functionality:
 // 1. Connect to the GTalk network and register the machine as a host.
@@ skipping 23 matching lines @@
 #include "net/socket/ssl_server_socket.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/constants.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/dns_blackhole_checker.h"
 #include "remoting/host/event_executor.h"
+#include "remoting/host/desktop_environment.h"
+#include "remoting/host/desktop_environment_factory.h"
 #include "remoting/host/heartbeat_sender.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/json_host_config.h"
 #include "remoting/host/log_to_server.h"
 #include "remoting/host/network_settings.h"
 #include "remoting/host/register_support_host_request.h"
 #include "remoting/host/session_manager_factory.h"
 #include "remoting/host/signaling_connector.h"
@@ skipping 33 matching lines @@
 const char kMaxPortSwitchName[] = "max-port";
 
 const char kVideoSwitchValueVerbatim[] = "verbatim";
 const char kVideoSwitchValueZip[] = "zip";
 const char kVideoSwitchValueVp8[] = "vp8";
 
 }  // namespace
 
 namespace remoting {
 
+class FakeDesktopEnvironmentFactory : public DesktopEnvironmentFactory {
+ public:
+  FakeDesktopEnvironmentFactory();
+  virtual ~FakeDesktopEnvironmentFactory();
+
+  virtual scoped_ptr<DesktopEnvironment> Create(
+      ChromotingHostContext* context) OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeDesktopEnvironmentFactory);
+};
+
+FakeDesktopEnvironmentFactory::FakeDesktopEnvironmentFactory() {
+}
+
+FakeDesktopEnvironmentFactory::~FakeDesktopEnvironmentFactory() {
+}
+
+scoped_ptr<DesktopEnvironment> FakeDesktopEnvironmentFactory::Create(
+    ChromotingHostContext* context) {
+  scoped_ptr<VideoFrameCapturer> capturer(new VideoFrameCapturerFake());
+  scoped_ptr<EventExecutor> event_executor = EventExecutor::Create(
+      context->desktop_task_runner(),
+      context->ui_task_runner());
+  scoped_ptr<AudioCapturer> audio_capturer(NULL);
+  return scoped_ptr<DesktopEnvironment>(new DesktopEnvironment(
+      audio_capturer.Pass(),
+      event_executor.Pass(),
+      capturer.Pass()));
+}
+
 class SimpleHost : public HeartbeatSender::Listener {
  public:
   SimpleHost()
       : message_loop_(MessageLoop::TYPE_UI),
         context_(new AutoThreadTaskRunner(message_loop_.message_loop_proxy())),
         fake_(false),
         is_it2me_(false),
         shutting_down_(false),
         exit_code_(kSuccessExitCode) {
     context_.Start();
@@ skipping 115 matching lines @@
     signal_strategy_.reset(new XmppSignalStrategy(
         context_.url_request_context_getter(),
         xmpp_login_, xmpp_auth_token_, xmpp_auth_service_));
     scoped_ptr<DnsBlackholeChecker> dns_blackhole_checker(
         new DnsBlackholeChecker(&context_, kDefaultHostTalkGadgetPrefix));
     signaling_connector_.reset(new SignalingConnector(
         signal_strategy_.get(), &context_, dns_blackhole_checker.Pass(),
         base::Bind(&SimpleHost::OnAuthFailed, base::Unretained(this))));
 
     if (fake_) {
-      scoped_ptr<VideoFrameCapturer> capturer(new VideoFrameCapturerFake());
-      scoped_ptr<EventExecutor> event_executor = EventExecutor::Create(
-          context_.desktop_task_runner(),
-          context_.ui_task_runner());
-      scoped_ptr<AudioCapturer> audio_capturer(NULL);
-      desktop_environment_ = DesktopEnvironment::CreateFake(
-          &context_,
-          capturer.Pass(),
-          event_executor.Pass(),
-          audio_capturer.Pass());
+      desktop_environment_factory_.reset(new FakeDesktopEnvironmentFactory());
     } else {
-      desktop_environment_ = DesktopEnvironment::Create(&context_);
+      desktop_environment_factory_.reset(new DesktopEnvironmentFactory());
     }
 
     host_ = new ChromotingHost(
-        &context_, signal_strategy_.get(), desktop_environment_.get(),
+        &context_, signal_strategy_.get(), desktop_environment_factory_.get(),
         CreateHostSessionManager(network_settings_,
                                  context_.url_request_context_getter()));
 
     ServerLogEntry::Mode mode =
         is_it2me_ ? ServerLogEntry::IT2ME : ServerLogEntry::ME2ME;
     log_to_server_.reset(new LogToServer(host_, mode, signal_strategy_.get()));
 
     if (is_it2me_) {
       it2me_host_user_interface_.reset(new It2MeHostUserInterface(&context_));
       it2me_host_user_interface_->Start(
@@ skipping 66 matching lines @@
   NetworkSettings network_settings_;
   scoped_ptr<CandidateSessionConfig> protocol_config_;
 
   std::string host_id_;
   HostKeyPair key_pair_;
   protocol::SharedSecretHash host_secret_hash_;
   std::string xmpp_login_;
   std::string xmpp_auth_token_;
   std::string xmpp_auth_service_;
 
+  scoped_ptr<DesktopEnvironmentFactory> desktop_environment_factory_;
   scoped_ptr<XmppSignalStrategy> signal_strategy_;
   scoped_ptr<DnsBlackholeChecker> dns_blackhole_checker_;
   scoped_ptr<SignalingConnector> signaling_connector_;
-  scoped_ptr<DesktopEnvironment> desktop_environment_;
   scoped_ptr<LogToServer> log_to_server_;
   scoped_ptr<It2MeHostUserInterface> it2me_host_user_interface_;
   scoped_ptr<RegisterSupportHostRequest> register_request_;
   scoped_ptr<HeartbeatSender> heartbeat_sender_;
 
   scoped_refptr<ChromotingHost> host_;
 
   bool shutting_down_;
   int exit_code_;
 };
@@ skipping 90 matching lines @@
         max_port < 0 || max_port > 65535) {
       LOG(ERROR) << "Invalid max-port value: " << max_port
                  << ". Expected integer in range [0, 65535].";
       return 1;
     }
     simple_host.network_settings()->max_port = max_port;
   }
 
   return simple_host.Run();
 }