Pass a DesktopEnvironmentFactory when creating DesktopProcess.

remoting/host/desktop_session_agent.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/desktop_session_agent.h"
 
 #include "base/logging.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "media/video/capture/screen/screen_capture_data.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/util.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
+#include "remoting/host/desktop_environment.h"
 #include "remoting/host/disconnect_window.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/local_input_monitor.h"
 #include "remoting/host/remote_input_filter.h"
 #include "remoting/proto/audio.pb.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/input_event_tracker.h"
 #include "third_party/skia/include/core/SkRegion.h"
@@ skipping 142 matching lines @@
   DCHECK(buffer->id() != 0);
 
   SendToNetwork(
       new ChromotingDesktopNetworkMsg_ReleaseSharedBuffer(buffer->id()));
 }
 
 void DesktopSessionAgent::OnStartSessionAgent(
     const std::string& authenticated_jid) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
   DCHECK(!started_);
+  DCHECK(!audio_capturer_);
+  DCHECK(!event_executor_);
+  DCHECK(!video_capturer_);
 
   started_ = true;
 
+  // Create a desktop environment for the new session.
+  base::Closure disconnect_session =
+      base::Bind(&DesktopSessionAgent::DisconnectSession, this);
+  scoped_ptr<DesktopEnvironment> desktop_environment =
+      delegate_->desktop_environment_factory().Create(authenticated_jid,
+                                                      disconnect_session);
+
   // Create the event executor.
-  event_executor_ = CreateEventExecutor();
+  event_executor_ =
+      desktop_environment->CreateEventExecutor(input_task_runner(),
+                                               caller_task_runner());
 
   // Hook up the input filter
   input_tracker_.reset(new protocol::InputEventTracker(event_executor_.get()));
   remote_input_filter_.reset(new RemoteInputFilter(input_tracker_.get()));
 
   // Start the event executor.
   scoped_ptr<protocol::ClipboardStub> clipboard_stub(
       new DesktopSesssionClipboardStub(this));
   event_executor_->Start(clipboard_stub.Pass());
 
-  base::Closure disconnect_session =
-      base::Bind(&DesktopSessionAgent::DisconnectSession, this);
-
   // Create the disconnect window.
   disconnect_window_ = DisconnectWindow::Create(&ui_strings_);
   disconnect_window_->Show(
       disconnect_session,
       authenticated_jid.substr(0, authenticated_jid.find('/')));
 
   // Start monitoring local input.
   local_input_monitor_ = LocalInputMonitor::Create();
   local_input_monitor_->Start(this, disconnect_session);
 
   // Start the audio capturer.
-  audio_capture_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&DesktopSessionAgent::StartAudioCapturer, this));
+  if (delegate_->desktop_environment_factory().SupportsAudioCapture()) {
+    audio_capturer_ = desktop_environment->CreateAudioCapturer(
+        audio_capture_task_runner());
+    audio_capture_task_runner()->PostTask(
+        FROM_HERE, base::Bind(&DesktopSessionAgent::StartAudioCapturer, this));
+  }
 
   // Start the video capturer.
+  video_capturer_ = desktop_environment->CreateVideoCapturer(
+      video_capture_task_runner(), caller_task_runner());
   video_capture_task_runner()->PostTask(
       FROM_HERE, base::Bind(&DesktopSessionAgent::StartVideoCapturer, this));
 }
 
 void DesktopSessionAgent::OnCaptureCompleted(
     scoped_refptr<media::ScreenCaptureData> capture_data) {
   DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
 
   current_size_ = capture_data->size();
 
@@ skipping 241 matching lines @@
   if (network_channel_) {
     network_channel_->Send(message);
   } else {
     delete message;
   }
 }
 
 void DesktopSessionAgent::StartAudioCapturer() {
   DCHECK(audio_capture_task_runner()->BelongsToCurrentThread());
 
-  audio_capturer_ = AudioCapturer::Create();
   if (audio_capturer_) {
     audio_capturer_->Start(base::Bind(&DesktopSessionAgent::ProcessAudioPacket,
                                       this));
   }
 }
 
 void DesktopSessionAgent::StopAudioCapturer() {
   DCHECK(audio_capture_task_runner()->BelongsToCurrentThread());
 
   audio_capturer_.reset();
 }
 
 void DesktopSessionAgent::StartVideoCapturer() {
   DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
 
-  video_capturer_ = media::ScreenCapturer::Create();
   if (video_capturer_)
     video_capturer_->Start(this);
 }
 
 void DesktopSessionAgent::StopVideoCapturer() {
   DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
 
   if (video_capturer_) {
     video_capturer_->Stop();
     video_capturer_.reset();
@@ skipping 14 matching lines @@
       input_task_runner_(input_task_runner),
       io_task_runner_(io_task_runner),
       video_capture_task_runner_(video_capture_task_runner),
       current_size_(SkISize::Make(0, 0)),
       next_shared_buffer_id_(1),
       started_(false) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 }
 
 }  // namespace remoting