Reusing names of policy keys from policy_constants.h

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 11 matching lines @@
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "media/base/media.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/ssl_server_socket.h"
 #include "net/url_request/url_fetcher.h"
+#include "policy/policy_constants.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/breakpad.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/logging.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/base/service_urls.h"
 #include "remoting/base/util.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
@@ skipping 968 matching lines @@
       LOG(ERROR) << "The host domain does not match the policy.";
       ShutdownHost(kInvalidHostDomainExitCode);
     }
   }
 }
 
 bool HostProcess::OnHostDomainPolicyUpdate(base::DictionaryValue* policies) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  if (!policies->GetString(policy_hack::PolicyWatcher::kHostDomainPolicyName,
-                          &host_domain_)) {
+  if (!policies->GetString(policy::key::kRemoteAccessHostDomain,
+                           &host_domain_)) {
     return false;
   }
 
   ApplyHostDomainPolicy();
   return false;
 }
 
 void HostProcess::ApplyUsernamePolicy() {
   if (host_username_match_required_) {
     HOST_LOG << "Policy requires host username match.";
@@ skipping 34 matching lines @@
     }
   } else {
     HOST_LOG << "Policy does not require host username match.";
   }
 }
 
 bool HostProcess::OnUsernamePolicyUpdate(base::DictionaryValue* policies) {
   // Returns false: never restart the host after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  if (!policies->GetBoolean(
-      policy_hack::PolicyWatcher::kHostMatchUsernamePolicyName,
-      &host_username_match_required_)) {
+  if (!policies->GetBoolean(policy::key::kRemoteAccessHostMatchUsername,
+                            &host_username_match_required_)) {
     return false;
   }
 
   ApplyUsernamePolicy();
   return false;
 }
 
 bool HostProcess::OnNatPolicyUpdate(base::DictionaryValue* policies) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  if (!policies->GetBoolean(policy_hack::PolicyWatcher::kNatPolicyName,
-                           &allow_nat_traversal_)) {
+  if (!policies->GetBoolean(policy::key::kRemoteAccessHostFirewallTraversal,
+                            &allow_nat_traversal_)) {
     return false;
   }
 
   if (allow_nat_traversal_) {
     HOST_LOG << "Policy enables NAT traversal.";
   } else {
     HOST_LOG << "Policy disables NAT traversal.";
   }
   return true;
 }
 
 bool HostProcess::OnRelayPolicyUpdate(base::DictionaryValue* policies) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  if (!policies->GetBoolean(policy_hack::PolicyWatcher::kRelayPolicyName,
-                           &allow_relay_)) {
+  if (!policies->GetBoolean(
+          policy::key::kRemoteAccessHostAllowRelayedConnection,
+          &allow_relay_)) {
     return false;
   }
 
   if (allow_relay_) {
     HOST_LOG << "Policy enables use of relay server.";
   } else {
     HOST_LOG << "Policy disables use of relay server.";
   }
   return true;
 }
 
 bool HostProcess::OnUdpPortPolicyUpdate(base::DictionaryValue* policies) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   std::string udp_port_range;
-  if (!policies->GetString(policy_hack::PolicyWatcher::kUdpPortRangePolicyName,
+  if (!policies->GetString(policy::key::kRemoteAccessHostUdpPortRange,
                            &udp_port_range)) {
     return false;
   }
 
   // Use default values if policy setting is empty or invalid.
   uint16 min_udp_port = 0;
   uint16 max_udp_port = 0;
   if (!udp_port_range.empty() &&
       !NetworkSettings::ParsePortRange(udp_port_range, &min_udp_port,
                                        &max_udp_port)) {
@@ skipping 12 matching lines @@
     max_udp_port_ = max_udp_port;
     return true;
   }
   return false;
 }
 
 bool HostProcess::OnCurtainPolicyUpdate(base::DictionaryValue* policies) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  if (!policies->GetBoolean(
-          policy_hack::PolicyWatcher::kHostRequireCurtainPolicyName,
-          &curtain_required_)) {
+  if (!policies->GetBoolean(policy::key::kRemoteAccessHostRequireCurtain,
+                            &curtain_required_)) {
     return false;
   }
 
 #if defined(OS_MACOSX)
   if (curtain_required_) {
     // When curtain mode is in effect on Mac, the host process runs in the
     // user's switched-out session, but launchd will also run an instance at
     // the console login screen.  Even if no user is currently logged-on, we
     // can't support remote-access to the login screen because the current host
     // process model disconnects the client during login, which would leave
@@ skipping 19 matching lines @@
   if (host_)
     host_->SetEnableCurtaining(curtain_required_);
   return false;
 }
 
 bool HostProcess::OnHostTalkGadgetPrefixPolicyUpdate(
     base::DictionaryValue* policies) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  if (!policies->GetString(
-          policy_hack::PolicyWatcher::kHostTalkGadgetPrefixPolicyName,
-          &talkgadget_prefix_)) {
+  if (!policies->GetString(policy::key::kRemoteAccessHostTalkGadgetPrefix,
+                           &talkgadget_prefix_)) {
     return false;
   }
 
   HOST_LOG << "Policy sets talkgadget prefix: " << talkgadget_prefix_;
   return true;
 }
 
 bool HostProcess::OnHostTokenUrlPolicyUpdate(base::DictionaryValue* policies) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   bool token_policy_changed = false;
   std::string token_url_string;
-  if (policies->GetString(
-          policy_hack::PolicyWatcher::kHostTokenUrlPolicyName,
-          &token_url_string)) {
+  if (policies->GetString(policy::key::kRemoteAccessHostTokenUrl,
+                          &token_url_string)) {
     token_policy_changed = true;
     third_party_auth_config_.token_url = GURL(token_url_string);
   }
   std::string token_validation_url_string;
-  if (policies->GetString(
-          policy_hack::PolicyWatcher::kHostTokenValidationUrlPolicyName,
-          &token_validation_url_string)) {
+  if (policies->GetString(policy::key::kRemoteAccessHostTokenValidationUrl,
+                          &token_validation_url_string)) {
     token_policy_changed = true;
     third_party_auth_config_.token_validation_url =
         GURL(token_validation_url_string);
   }
   if (policies->GetString(
-          policy_hack::PolicyWatcher::kHostTokenValidationCertIssuerPolicyName,
+          policy::key::kRemoteAccessHostTokenValidationCertificateIssuer,
           &third_party_auth_config_.token_validation_cert_issuer)) {
     token_policy_changed = true;
   }
 
   if (token_policy_changed) {
     HOST_LOG << "Policy sets third-party token URLs: "
              << "TokenUrl: "
              << third_party_auth_config_.token_url << ", "
              << "TokenValidationUrl: "
              << third_party_auth_config_.token_validation_url << ", "
              << "TokenValidationCertificateIssuer: "
              << third_party_auth_config_.token_validation_cert_issuer;
   }
   return token_policy_changed;
 }
 
 bool HostProcess::OnPairingPolicyUpdate(base::DictionaryValue* policies) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  if (!policies->GetBoolean(
-          policy_hack::PolicyWatcher::kHostAllowClientPairing,
-          &allow_pairing_)) {
+  if (!policies->GetBoolean(policy::key::kRemoteAccessHostAllowClientPairing,
+                            &allow_pairing_)) {
     return false;
   }
 
   if (allow_pairing_) {
     HOST_LOG << "Policy enables client pairing.";
   } else {
     HOST_LOG << "Policy disables client pairing.";
   }
   return true;
 }
 
 bool HostProcess::OnGnubbyAuthPolicyUpdate(base::DictionaryValue* policies) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  if (!policies->GetBoolean(
-          policy_hack::PolicyWatcher::kHostAllowGnubbyAuthPolicyName,
-          &enable_gnubby_auth_)) {
+  if (!policies->GetBoolean(policy::key::kRemoteAccessHostAllowGnubbyAuth,
+                            &enable_gnubby_auth_)) {
     return false;
   }
 
   if (enable_gnubby_auth_) {
     HOST_LOG << "Policy enables gnubby auth.";
   } else {
     HOST_LOG << "Policy disables gnubby auth.";
   }
 
   if (desktop_environment_factory_)
@@ skipping 238 matching lines @@
       base::TimeDelta::FromSeconds(kShutdownTimeoutSeconds));
   new HostProcess(context.Pass(), &exit_code, &shutdown_watchdog);
 
   // Run the main (also UI) message loop until the host no longer needs it.
   message_loop.Run();
 
   return exit_code;
 }
 
 }  // namespace remoting