Enable RDP integration by default when the curtain mode is enabled by the policy.

remoting/host/remoting_me2me_host.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 file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 184 matching lines @@
   void SendSasToConsole();
 
   // Tear down resources that run on the UI thread.
   void ShutdownOnUiThread();
 
   // Applies the host config, returning true if successful.
   bool ApplyConfig(scoped_ptr<JsonHostConfig> config);
 
   void OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies);
   bool OnHostDomainPolicyUpdate(const std::string& host_domain);
-  bool OnUsernamePolicyUpdate(bool username_match_required);
+  bool OnUsernamePolicyUpdate(bool curtain_required,
+                              bool username_match_required);
   bool OnNatPolicyUpdate(bool nat_traversal_enabled);
   bool OnCurtainPolicyUpdate(bool curtain_required);
   bool OnHostTalkGadgetPrefixPolicyUpdate(const std::string& talkgadget_prefix);
   bool OnHostTokenUrlPolicyUpdate(const GURL& token_url,
                                   const GURL& token_validation_url);
 
   void StartHost();
 
   void OnAuthFailed();
 
@@ skipping 501 matching lines @@
     return;
   }
 
   bool restart_required = false;
   bool bool_value;
   std::string string_value;
   if (policies->GetString(policy_hack::PolicyWatcher::kHostDomainPolicyName,
                           &string_value)) {
     restart_required |= OnHostDomainPolicyUpdate(string_value);
   }
+  bool curtain_required = false;
+  if (policies->GetBoolean(
+          policy_hack::PolicyWatcher::kHostRequireCurtainPolicyName,
+          &curtain_required)) {
+    restart_required |= OnCurtainPolicyUpdate(curtain_required);
+  }
   if (policies->GetBoolean(
       policy_hack::PolicyWatcher::kHostMatchUsernamePolicyName,
       &bool_value)) {
-    restart_required |= OnUsernamePolicyUpdate(bool_value);
+    restart_required |= OnUsernamePolicyUpdate(curtain_required, bool_value);
   }
   if (policies->GetBoolean(policy_hack::PolicyWatcher::kNatPolicyName,
                            &bool_value)) {
     restart_required |= OnNatPolicyUpdate(bool_value);
   }
   if (policies->GetString(
           policy_hack::PolicyWatcher::kHostTalkGadgetPrefixPolicyName,
           &string_value)) {
     restart_required |= OnHostTalkGadgetPrefixPolicyUpdate(string_value);
   }
-  if (policies->GetBoolean(
-          policy_hack::PolicyWatcher::kHostRequireCurtainPolicyName,
-          &bool_value)) {
-    restart_required |= OnCurtainPolicyUpdate(bool_value);
-  }
   std::string token_url_string, token_validation_url_string;
   if (policies->GetString(
           policy_hack::PolicyWatcher::kHostTokenUrlPolicyName,
           &token_url_string) &&
       policies->GetString(
           policy_hack::PolicyWatcher::kHostTokenValidationUrlPolicyName,
           &token_validation_url_string)) {
     restart_required |= OnHostTokenUrlPolicyUpdate(
         GURL(token_url_string), GURL(token_validation_url_string));
   }
@@ skipping 11 matching lines @@
 
   LOG(INFO) << "Policy sets host domain: " << host_domain;
 
   if (!host_domain.empty() &&
       !EndsWith(xmpp_login_, std::string("@") + host_domain, false)) {
     ShutdownHost(kInvalidHostDomainExitCode);
   }
   return false;
 }
 
-bool HostProcess::OnUsernamePolicyUpdate(bool host_username_match_required) {
+bool HostProcess::OnUsernamePolicyUpdate(bool curtain_required,
+                                         bool host_username_match_required) {
   // Returns false: never restart the host after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (host_username_match_required) {
     LOG(INFO) << "Policy requires host username match.";
     std::string username = GetUsername();
     bool shutdown = username.empty() ||
         !StartsWithASCII(xmpp_login_, username + std::string("@"),
                          false);
 
 #if defined(OS_MACOSX)
     // On Mac, we run as root at the login screen, so the username won't match.
     // However, there's no need to enforce the policy at the login screen, as
     // the client will have to reconnect if a login occurs.
     if (shutdown && getuid() == 0) {
       shutdown = false;
     }
 #endif
 
+    // Curtain-mode on Windows presents the standard OS login prompt to the user
+    // for each connection, removing the need for an explicit user-name matching
+    // check.
+#if defined(OS_WIN) && defined(REMOTING_RDP_SESSION)
+    if (curtain_required)
+      return false;
+#endif  // defined(OS_WIN) && defined(REMOTING_RDP_SESSION)
+
+    // Shutdown the host if the username does not match.
     if (shutdown) {
       LOG(ERROR) << "The host username does not match.";
       ShutdownHost(kUsernameMismatchExitCode);
     }
   } else {
     LOG(INFO) << "Policy does not require host username match.";
   }
 
   return false;
 }
@@ skipping 336 matching lines @@
   return exit_code;
 }
 
 }  // namespace remoting
 
 #if !defined(OS_WIN)
 int main(int argc, char** argv) {
   return remoting::HostMain(argc, argv);
 }
 #endif  // !defined(OS_WIN)