New policies: enable/disable relay; port range

remoting/host/policy_hack/policy_watcher.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.
 
 // Most of this code is copied from:
 //   src/chrome/browser/policy/asynchronous_policy_loader.{h,cc}
 
 #include "remoting/host/policy_hack/policy_watcher.h"
 
 #include "base/bind.h"
@@ skipping 59 matching lines @@
 #endif  // defined(NDEBUG)
 
   return to.Pass();
 }
 
 }  // namespace
 
 const char PolicyWatcher::kNatPolicyName[] =
     "RemoteAccessHostFirewallTraversal";
 
+const char PolicyWatcher::kRelayPolicyName[] =

[Sergey Ulanov, 2014/03/24 23:37:12]

The new policies also need to be added in
chrome/app/policy/policy_templates.json .  See
https://chromiumcodereview.appspot.com/20864002 for example.

[dcaiafa, 2014/03/26 15:29:16]

Done.

+    "RemoteAccessHostAllowRelayedConnection";
+
+const char PolicyWatcher::kUdpPortRangePolicyName[] =
+    "RemoteAccessHostUdpPortRange";
+
 const char PolicyWatcher::kHostRequireTwoFactorPolicyName[] =
     "RemoteAccessHostRequireTwoFactor";
 
 const char PolicyWatcher::kHostDomainPolicyName[] =
     "RemoteAccessHostDomain";
 
 const char PolicyWatcher::kHostMatchUsernamePolicyName[] =
     "RemoteAccessHostMatchUsername";
 
 const char PolicyWatcher::kHostTalkGadgetPrefixPolicyName[] =
@@ skipping 21 matching lines @@
     "RemoteAccessHostDebugOverridePolicies";
 
 PolicyWatcher::PolicyWatcher(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : task_runner_(task_runner),
       old_policies_(new base::DictionaryValue()),
       default_values_(new base::DictionaryValue()),
       weak_factory_(this) {
   // Initialize the default values for each policy.
   default_values_->SetBoolean(kNatPolicyName, true);
+  default_values_->SetBoolean(kRelayPolicyName, true);
+  default_values_->SetString(kUdpPortRangePolicyName, "");
   default_values_->SetBoolean(kHostRequireTwoFactorPolicyName, false);
   default_values_->SetBoolean(kHostRequireCurtainPolicyName, false);
   default_values_->SetBoolean(kHostMatchUsernamePolicyName, false);
   default_values_->SetString(kHostDomainPolicyName, std::string());
   default_values_->SetString(kHostTalkGadgetPrefixPolicyName,
                                kDefaultHostTalkGadgetPrefix);
   default_values_->SetString(kHostTokenUrlPolicyName, std::string());
   default_values_->SetString(kHostTokenValidationUrlPolicyName, std::string());
   default_values_->SetString(kHostTokenValidationCertIssuerPolicyName,
                              std::string());
   default_values_->SetBoolean(kHostAllowClientPairing, true);
   default_values_->SetBoolean(kHostAllowGnubbyAuthPolicyName, true);
 #if !defined(NDEBUG)
   default_values_->SetString(kHostDebugOverridePoliciesName, std::string());
 #endif
 
   // Initialize the fall-back values to use for unreadable policies.
   // For most policies these match the defaults.
   bad_type_values_.reset(default_values_->DeepCopy());
   bad_type_values_->SetBoolean(kNatPolicyName, false);
+  bad_type_values_->SetBoolean(kRelayPolicyName, false);
 }
 
 PolicyWatcher::~PolicyWatcher() {
 }
 
 void PolicyWatcher::StartWatching(const PolicyCallback& policy_callback) {
   if (!OnPolicyWatcherThread()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&PolicyWatcher::StartWatching,
                                       base::Unretained(this),
@@ skipping 68 matching lines @@
   old_policies_.swap(new_policies);
 
   // Notify our client of the changed policies.
   if (!changed_policies->empty()) {
     policy_callback_.Run(changed_policies.Pass());
   }
 }
 
 }  // namespace policy_hack
 }  // namespace remoting