Pass the |curtain_activated| flag to IpcDesktopEnvironmentFactory.

remoting/host/ipc_desktop_environment.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/ipc_desktop_environment.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/single_thread_task_runner.h"
 #include "ipc/ipc_sender.h"
 #include "media/video/capture/screen/screen_capturer.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/desktop_session_proxy.h"
 #include "remoting/host/event_executor.h"
 
 namespace remoting {
 
 IpcDesktopEnvironment::IpcDesktopEnvironment(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     const std::string& client_jid,
     const base::Closure& disconnect_callback,
-    base::WeakPtr<DesktopSessionConnector> desktop_session_connector)
+    base::WeakPtr<DesktopSessionConnector> desktop_session_connector,
+    bool curtain_required)
     : caller_task_runner_(caller_task_runner),
       connected_(false),
       desktop_session_connector_(desktop_session_connector),
       desktop_session_proxy_(new DesktopSessionProxy(caller_task_runner,
                                                      io_task_runner,
                                                      client_jid,
                                                      disconnect_callback)) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 }
 
@@ skipping 40 matching lines @@
     desktop_session_connector_->ConnectTerminal(desktop_session_proxy_);
   }
 }
 
 IpcDesktopEnvironmentFactory::IpcDesktopEnvironmentFactory(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     IPC::Sender* daemon_channel)
     : caller_task_runner_(caller_task_runner),
       io_task_runner_(io_task_runner),
+      curtain_activated_(false),
       daemon_channel_(daemon_channel),
       connector_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       next_id_(0) {
 }
 
 IpcDesktopEnvironmentFactory::~IpcDesktopEnvironmentFactory() {
 }
 
+void IpcDesktopEnvironmentFactory::SetActivated(bool activated) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  curtain_activated_ = activated;

[rmsousa, 2013/03/04 21:56:36]

This isn't implementing the current curtain mode interface. 

SetActivated isn't a "stateless mode switch", it's a reactive call - it's only
called:
(1) when a new client authenticates;
(2) or when the policy changes to enable curtaining AND someone is already
connected; (kind of a special case)
(very theoretically there's case (3) when a host restarts AND there's someone
already connected, but that's impossible in practice)
And when it's called, it's supposed to do one of two things:
(1) Curtain the console immediately (Mac case); or
(2) Call on_error if this is an uncurtainable desktop (Linux case)

I think that, in this case particularly, the sequence will be that the
DesktopEnvironment is created in the OnIncomingSession event, and THEN the
OnClientAuthenticated event will happen to enable the curtain, i.e. it will be
too late for that desktop environment.

I think what you need to do isn't covered by the current curtain mode interface.
You need to:
Set this mode in the desktop environment factory when the policy changes (in
remoting_me2me_host).
Have SetActivated implementation that immediately rejects (calls on_error) the
session if it's not an RDP session (it somehow needs to have that information).

[alexeypa (please no reviews), 2013/03/04 22:16:03]

Yes, I know that. I'm preparing a couple of separate CLs that will result in
DesktopEnvironment to be created in
ClientSession::OnConnectionChannelsConnected() - after the curtain was enabled.

I nice catch though!
Agree. I'm trying to keep the changes to curtain mode code to the minimum. There
are way to many other changes in flight right now. It should be relatively
straight-forward refactoring once we have time for it.
The sequence will be:

1. OnConnectionAuthenticated() causes SetActivated() to be called.
2. OnConnectionChannelsConnected() creates desktop environment, creates event
executor, etc. and frees the desktop environment.
    2.1. This will also cause DesktopSessionProxy to register with the daemon.
3. The daemon will try to attach to a session of requested kind, checking the
curtain flag as well. If it fails it will kill the client session.

[rmsousa, 2013/03/04 23:33:54]

Can you add a comment stating something like "This doesn't currently work. TODO:
Have 
DesktopEnvironment be created after the curtain is enabled."
(I would actually prefer to have this go in immediately before or together with
the other changes you mentioned, as this temporarily creates a situation where
the RDP-enabled host doesn't enforce the curtain policy).
This will work (once the other pieces are in), but it's still a bit odd to be
setting/resetting the flag for every connection/disconnection. But it kinda
makes sense if we think about it as activating/deactivating the curtain.

This also won't do anything if the policy is enabled while someone is already
connected to the console (where the other implementations either kick everyone
or turn on the curtain immediately). Currently we restart the host immediately
after that anyway (kicking everyone out in the process), so that's not a
problem, but since the other curtain mode implementations work in this case, I
think we need at least a comment here (or in OnCurtainPolicyUpdated) that RDP
curtaining relies on the host restart, and that we'll need to add code to check
if there are non-RDP sessions and kick everyone out if that assumption ever
changes.

[alexeypa (please no reviews), 2013/03/05 00:19:48]

Done.
This should not be a problem because RDP intergation is not enabled unless
remoting_rdp_session% GYP variable is set. It is currently disabled by default.
Done.

+}
+
 scoped_ptr<DesktopEnvironment> IpcDesktopEnvironmentFactory::Create(
     const std::string& client_jid,
     const base::Closure& disconnect_callback) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   return scoped_ptr<DesktopEnvironment>(new IpcDesktopEnvironment(
       caller_task_runner_, io_task_runner_, client_jid, disconnect_callback,
-      connector_factory_.GetWeakPtr()));
+      connector_factory_.GetWeakPtr(), curtain_activated_));
 }
 
 bool IpcDesktopEnvironmentFactory::SupportsAudioCapture() const {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   return AudioCapturer::IsSupported();
 }
 
 void IpcDesktopEnvironmentFactory::ConnectTerminal(
     scoped_refptr<DesktopSessionProxy> desktop_session_proxy) {
@@ skipping 65 matching lines @@
   if (i != active_connections_.end()) {
     scoped_refptr<DesktopSessionProxy> desktop_session_proxy = i->second;
     active_connections_.erase(i);
 
     // Disconnect the client session.
     desktop_session_proxy->DisconnectSession();
   }
 }
 
 }  // namespace remoting