Adding a policy for using the uiAccess enabled It2Me binary on Windows

remoting/host/policy_watcher_unittest.cc

 // Copyright 2015 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/policy_watcher.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 130 matching lines @@
                                         "https://token.com");
     third_party_auth_partial_.SetString(
         key::kRemoteAccessHostTokenValidationUrl, "https://validation.com");
     third_party_auth_full_.MergeDictionary(&third_party_auth_partial_);
     third_party_auth_full_.SetString(
         key::kRemoteAccessHostTokenValidationCertificateIssuer,
         "certificate subject");
     third_party_auth_cert_empty_.MergeDictionary(&third_party_auth_partial_);
     third_party_auth_cert_empty_.SetString(
         key::kRemoteAccessHostTokenValidationCertificateIssuer, "");
+    remote_assistance_uiaccess_true_.SetBoolean(
+        key::kRemoteAssistanceHostAllowUiAccess, true);
+    remote_assistance_uiaccess_false_.SetBoolean(
+        key::kRemoteAssistanceHostAllowUiAccess, false);
   }
 
   void TearDown() override {
     policy_watcher_.reset();
     policy_loader_ = nullptr;
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   void StartWatching() {
@@ skipping 70 matching lines @@
   base::DictionaryValue port_range_malformed_;
   base::DictionaryValue port_range_malformed_domain_full_;
   base::DictionaryValue curtain_true_;
   base::DictionaryValue curtain_false_;
   base::DictionaryValue username_true_;
   base::DictionaryValue username_false_;
   base::DictionaryValue talk_gadget_blah_;
   base::DictionaryValue third_party_auth_full_;
   base::DictionaryValue third_party_auth_partial_;
   base::DictionaryValue third_party_auth_cert_empty_;
+  base::DictionaryValue remote_assistance_uiaccess_true_;
+  base::DictionaryValue remote_assistance_uiaccess_false_;
 
  private:
   void SetDefaults(base::DictionaryValue& dict) {
     dict.SetBoolean(key::kRemoteAccessHostFirewallTraversal, true);
     dict.SetBoolean(key::kRemoteAccessHostAllowRelayedConnection, true);
     dict.SetString(key::kRemoteAccessHostUdpPortRange, "");
     dict.SetString(key::kRemoteAccessHostClientDomain, std::string());
     dict.SetString(key::kRemoteAccessHostDomain, std::string());
     dict.SetBoolean(key::kRemoteAccessHostMatchUsername, false);
     dict.SetString(key::kRemoteAccessHostTalkGadgetPrefix,
                    kDefaultHostTalkGadgetPrefix);
     dict.SetBoolean(key::kRemoteAccessHostRequireCurtain, false);
     dict.SetString(key::kRemoteAccessHostTokenUrl, "");
     dict.SetString(key::kRemoteAccessHostTokenValidationUrl, "");
     dict.SetString(key::kRemoteAccessHostTokenValidationCertificateIssuer, "");
     dict.SetBoolean(key::kRemoteAccessHostAllowClientPairing, true);
     dict.SetBoolean(key::kRemoteAccessHostAllowGnubbyAuth, true);
+    dict.SetBoolean(key::kRemoteAssistanceHostAllowUiAccess, false);
 
     ASSERT_THAT(&dict, IsPolicies(&GetDefaultValues()))
         << "Sanity check that defaults expected by the test code "
         << "match what is stored in PolicyWatcher::default_values_";
   }
 };
 
 const char* PolicyWatcherTest::kHostDomain = "google.com";
 const char* PolicyWatcherTest::kPortRange = "12400-12409";
 
@@ skipping 216 matching lines @@
               OnPolicyUpdatePtr(IsPolicies(&gnubby_auth_false_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&gnubby_auth_true_)));
 
   SetPolicies(empty_);
   StartWatching();
   SetPolicies(gnubby_auth_false_);
   SetPolicies(gnubby_auth_true_);
 }
 
+TEST_F(PolicyWatcherTest, RemoteAssistanceUiAccess) {
+  testing::InSequence sequence;
+  EXPECT_CALL(mock_policy_callback_,
+              OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
+#if defined(OS_WIN)
+  // This setting only affects Windows, it is ignored on other platforms so the
+  // 2 SetPolicies calls won't result in any calls to OnPolicyUpdate.
+  EXPECT_CALL(mock_policy_callback_,
+              OnPolicyUpdatePtr(IsPolicies(&remote_assistance_uiaccess_true_)));
+  EXPECT_CALL(
+      mock_policy_callback_,
+      OnPolicyUpdatePtr(IsPolicies(&remote_assistance_uiaccess_false_)));
+#endif  // defined(OS_WIN)
+
+  SetPolicies(empty_);
+  StartWatching();
+  SetPolicies(remote_assistance_uiaccess_true_);
+  SetPolicies(remote_assistance_uiaccess_false_);
+}
+
 TEST_F(PolicyWatcherTest, Relay) {
   testing::InSequence sequence;
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&relay_false_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&relay_true_)));
 
   SetPolicies(empty_);
@@ skipping 105 matching lines @@
 
   std::map<std::string, base::Value::Type> expected_schema;
   for (base::DictionaryValue::Iterator i(GetDefaultValues()); !i.IsAtEnd();
        i.Advance()) {
     expected_schema[i.key()] = i.value().GetType();
   }
 #if defined(OS_WIN)
   // RemoteAccessHostMatchUsername is marked in policy_templates.json as not
   // supported on Windows and therefore is (by design) excluded from the schema.
   expected_schema.erase(key::kRemoteAccessHostMatchUsername);
+#else  // !defined(OS_WIN)
+  // RemoteAssistanceHostAllowUiAccess does not exist on non-Windows platforms.
+  expected_schema.erase(key::kRemoteAssistanceHostAllowUiAccess);
 #endif
 
   std::map<std::string, base::Value::Type> actual_schema;
   const policy::Schema* schema = GetPolicySchema();
   ASSERT_TRUE(schema->valid());
   for (auto it = schema->GetPropertiesIterator(); !it.IsAtEnd(); it.Advance()) {
     std::string key = it.key();
-    if (key.find("RemoteAccessHost") == std::string::npos) {
+    if (key.find("RemoteAccessHost") == std::string::npos &&
+        key.find("RemoteAssistanceHost") == std::string::npos) {
       // For now PolicyWatcher::GetPolicySchema() mixes Chrome and Chromoting
       // policies, so we have to skip them here.
       continue;
     }
     actual_schema[key] = it.schema().type();
   }
 
   EXPECT_THAT(actual_schema, testing::ContainerEq(expected_schema));
 }
 
@@ skipping 10 matching lines @@
 
   // And check one, random "boolean" policy to see if the type propagated
   // correctly from policy_templates.json file.
   const policy::Schema boolean_schema =
       schema->GetKnownProperty("RemoteAccessHostRequireCurtain");
   EXPECT_TRUE(boolean_schema.valid());
   EXPECT_EQ(boolean_schema.type(), base::Value::Type::TYPE_BOOLEAN);
 }
 
 }  // namespace remoting