Create a desktop environment instance late so that it will see the curtain_required flag.

remoting/host/client_session.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/client_session.h"
 
 #include <algorithm>
 
 #include "base/message_loop_proxy.h"
 #include "media/video/capture/screen/screen_capturer.h"
@@ skipping 30 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     scoped_ptr<protocol::ConnectionToClient> connection,
     DesktopEnvironmentFactory* desktop_environment_factory,
     const base::TimeDelta& max_duration)
     : event_handler_(event_handler),
       connection_(connection.Pass()),
       connection_factory_(connection_.get()),
       client_jid_(connection_->session()->jid()),
-      // TODO(alexeypa): delay creation of |desktop_environment_| until
-      // the curtain is enabled.
-      desktop_environment_(desktop_environment_factory->Create(
-          client_jid_,
-          base::Bind(&protocol::ConnectionToClient::Disconnect,
-                     connection_factory_.GetWeakPtr()))),
+      desktop_environment_factory_(desktop_environment_factory),
       input_tracker_(&host_input_filter_),
       remote_input_filter_(&input_tracker_),
       mouse_clamping_filter_(&remote_input_filter_),
       disable_input_filter_(mouse_clamping_filter_.input_filter()),
       disable_clipboard_filter_(clipboard_echo_filter_.host_filter()),
       auth_input_filter_(&disable_input_filter_),
       auth_clipboard_filter_(&disable_clipboard_filter_),
       client_clipboard_factory_(clipboard_echo_filter_.client_filter()),
       max_duration_(max_duration),
       audio_task_runner_(audio_task_runner),
@@ skipping 85 matching lines @@
 
 void ClientSession::OnConnectionChannelsConnected(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
   DCHECK(!audio_scheduler_);
   DCHECK(!event_executor_);
   DCHECK(!session_controller_);
   DCHECK(!video_scheduler_);
 
+  scoped_ptr<DesktopEnvironment> desktop_environment =
+      desktop_environment_factory_->Create(
+          client_jid_,
+          base::Bind(&protocol::ConnectionToClient::Disconnect,
+                     connection_factory_.GetWeakPtr()));

[Wez, 2013/03/14 04:15:54]

ClientSession owns the DesktopEnvironment, so can't we
Bind(&ClientSession::Disconnect, Unretained(this))?

If we do that then I think we can get rid of |connection_factory_| as well, and
tear-down the DesktopEnvironment in OnConnectionClosed, instead.

That does depend upon DesktopEnvironmentFactory::Create() guaranteeing that the
supplied callback can only be called while the DesktopEnvironment actually
exists.

[alexeypa (please no reviews), 2013/03/14 19:09:06]

No, we can't. The callback is passed to DesktopSessionProxy which potentially
tears down later than ClientSession. 

[Wez, 2013/03/15 00:15:26]

That feels like IpcDesktopEnvironment/DesktopSessionProxy's problem to deal
with, not the caller's.  An issue for another CL, though.

+
   // Create the session controller.
-  session_controller_ = desktop_environment_->CreateSessionController();
+  session_controller_ = desktop_environment->CreateSessionController();
 
   // Create and start the event executor.
-  event_executor_ = desktop_environment_->CreateEventExecutor(
+  event_executor_ = desktop_environment->CreateEventExecutor(
       input_task_runner_, ui_task_runner_);
   event_executor_->Start(CreateClipboardProxy());
 
   // Connect the host clipboard and input stubs.
   host_input_filter_.set_input_stub(event_executor_.get());
   clipboard_echo_filter_.set_host_stub(event_executor_.get());
 
   SetDisableInputs(false);
 
   // Create a VideoEncoder based on the session's video channel configuration.
   scoped_ptr<VideoEncoder> video_encoder =
       CreateVideoEncoder(connection_->session()->config());
 
   // Create a VideoScheduler to pump frames from the capturer to the client.
   video_scheduler_ = VideoScheduler::Create(
       video_capture_task_runner_,
       video_encode_task_runner_,
       network_task_runner_,
-      desktop_environment_->CreateVideoCapturer(video_capture_task_runner_,
-                                                video_encode_task_runner_),
+      desktop_environment->CreateVideoCapturer(video_capture_task_runner_,
+                                               video_encode_task_runner_),
       video_encoder.Pass(),
       connection_->client_stub(),
       &mouse_clamping_filter_);
 
   // Create an AudioScheduler if audio is enabled, to pump audio samples.
   if (connection_->session()->config().is_audio_enabled()) {
     scoped_ptr<AudioEncoder> audio_encoder =
         CreateAudioEncoder(connection_->session()->config());
     audio_scheduler_ = AudioScheduler::Create(
         audio_task_runner_,
         network_task_runner_,
-        desktop_environment_->CreateAudioCapturer(audio_task_runner_),
+        desktop_environment->CreateAudioCapturer(audio_task_runner_),
         audio_encoder.Pass(),
         connection_->audio_stub());
   }
 
   // Notify the event handler that all our channels are now connected.
   event_handler_->OnSessionChannelsConnected(this);
 }
 
 void ClientSession::OnConnectionClosed(
     protocol::ConnectionToClient* connection,
@@ skipping 119 matching lines @@
     return scoped_ptr<AudioEncoder>(new AudioEncoderSpeex());
   } else if (audio_config.codec == protocol::ChannelConfig::CODEC_OPUS) {
     return scoped_ptr<AudioEncoder>(new AudioEncoderOpus());
   }
 
   NOTIMPLEMENTED();
   return scoped_ptr<AudioEncoder>(NULL);
 }
 
 }  // namespace remoting