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

remoting/host/policy_watcher.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.
 
 // Most of this code is copied from:
 //   src/chrome/browser/policy/asynchronous_policy_loader.{h,cc}
 
 #include "remoting/host/policy_watcher.h"
 
 #include <utility>
@@ skipping 67 matching lines @@
   // policies (expecting perf and maintanability improvement, but no functional
   // impact).
   policy::Schema schema = policy::Schema::Wrap(policy::GetChromeSchemaData());
 
   std::unique_ptr<policy::SchemaRegistry> schema_registry(
       new policy::SchemaRegistry());
   schema_registry->RegisterComponent(GetPolicyNamespace(), schema);
   return schema_registry;
 }
 
+void RetrievePoliciesByNamePrefix(const policy::PolicyMap& current_policies,
+                                  const std::string& policy_name_prefix,
+                                  base::DictionaryValue* policy_dict) {
+  for (const auto& policy_entry : current_policies) {
+    const std::string& key = policy_entry.first;
+    const base::Value* value = policy_entry.second.value.get();
+
+    if (key.find(policy_name_prefix) != std::string::npos) {
+      policy_dict->Set(key, value->CreateDeepCopy());
+    }
+  }
+}
+
 std::unique_ptr<base::DictionaryValue> CopyChromotingPoliciesIntoDictionary(
     const policy::PolicyMap& current) {
-  const char kPolicyNameSubstring[] = "RemoteAccessHost";
+  const char kRemoteAccessHostPolicyNamePrefix[] = "RemoteAccessHost";
+  const char kRemoteAssistanceHostPolicyNamePrefix[] = "RemoteAssistanceHost";
   std::unique_ptr<base::DictionaryValue> policy_dict(
       new base::DictionaryValue());
-  for (const auto& entry : current) {
-    const std::string& key = entry.first;
-    const base::Value* value = entry.second.value.get();
 
-    // Copying only Chromoting-specific policies helps avoid false alarms
-    // raised by NormalizePolicies below (such alarms shutdown the host).
-    // TODO(lukasza): Removing this somewhat brittle filtering will be possible
-    //                after having separate, Chromoting-specific schema.
-    if (key.find(kPolicyNameSubstring) != std::string::npos) {
-      policy_dict->Set(key, value->CreateDeepCopy());
-    }
-  }
+  // Copying only Chromoting-specific policies helps avoid false alarms raised
+  // by NormalizePolicies below (such alarms shutdown the host).
+  // TODO(lukasza): Removing this somewhat brittle filtering will be possible
+  //                after having separate, Chromoting-specific schema.
+  RetrievePoliciesByNamePrefix(current, kRemoteAccessHostPolicyNamePrefix,
+                               policy_dict.get());
+  RetrievePoliciesByNamePrefix(current, kRemoteAssistanceHostPolicyNamePrefix,
+                               policy_dict.get());
 
   return policy_dict;
 }
 
 // Takes a dictionary containing only 1) recognized policy names and 2)
 // well-typed policy values and further verifies policy contents.
 bool VerifyWellformedness(const base::DictionaryValue& changed_policies) {
   // Verify ThirdPartyAuthConfig policy.
   ThirdPartyAuthConfig not_used;
   switch (ThirdPartyAuthConfig::Parse(changed_policies, &not_used)) {
@@ skipping 73 matching lines @@
   default_values_->SetString(key::kRemoteAccessHostTokenUrl, std::string());
   default_values_->SetString(key::kRemoteAccessHostTokenValidationUrl,
                              std::string());
   default_values_->SetString(
       key::kRemoteAccessHostTokenValidationCertificateIssuer, std::string());
   default_values_->SetBoolean(key::kRemoteAccessHostAllowClientPairing, true);
   default_values_->SetBoolean(key::kRemoteAccessHostAllowGnubbyAuth, true);
   default_values_->SetBoolean(key::kRemoteAccessHostAllowRelayedConnection,
                               true);
   default_values_->SetString(key::kRemoteAccessHostUdpPortRange, "");
+  default_values_->SetBoolean(key::kRemoteAssistanceHostAllowUiAccess, false);
 }
 
 PolicyWatcher::~PolicyWatcher() {
   // Stop observing |policy_service_| if StartWatching() has been called.
   if (!policy_updated_callback_.is_null()) {
     policy_service_->RemoveObserver(policy::POLICY_DOMAIN_CHROME, this);
   }
 
   if (owned_policy_provider_) {
     owned_policy_provider_->Shutdown();
@@ skipping 174 matching lines @@
       CreateSchemaRegistry()));
 #else
 #error OS that is not yet supported by PolicyWatcher code.
 #endif
 
   return PolicyWatcher::CreateFromPolicyLoader(std::move(policy_loader));
 #endif  // !(OS_CHROMEOS)
 }
 
 }  // namespace remoting