[Chromoting] Add a host domain policy to the PolicyWatcher.

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 23 matching lines @@
   }
   const base::Value* value;
   if (dict->Get(key, &value) && value->IsType(base::Value::TYPE_BOOLEAN)) {
     bool bool_value;
     CHECK(value->GetAsBoolean(&bool_value));
     return bool_value;
   }
   return default_if_value_not_boolean;
 }
 
+// Gets a string from a dictionary, or returns a default value if the string
+// couldn't be read.
+std::string GetStringOrDefault(const base::DictionaryValue* dict,
+                               const char* key,
+                               const std::string& default_if_value_missing,
+                               const std::string& default_if_value_not_string) {
+  if (!dict->HasKey(key)) {
+    return default_if_value_missing;
+  }
+  const base::Value* value;
+  if (dict->Get(key, &value) && value->IsType(base::Value::TYPE_STRING)) {
+    std::string string_value;
+    CHECK(value->GetAsString(&string_value));
+    return string_value;
+  }
+  return default_if_value_not_string;
+}
+
 // Copies a boolean from one dictionary to another, using a default value
 // if the boolean couldn't be read from the first dictionary.
 void CopyBooleanOrDefault(base::DictionaryValue* to,
                           const base::DictionaryValue* from, const char* key,
                           bool default_if_value_missing,
                           bool default_if_value_not_boolean) {
   to->Set(key, base::Value::CreateBooleanValue(
       GetBooleanOrDefault(from, key, default_if_value_missing,
                           default_if_value_not_boolean)));
 }
 
+// Copies a string from one dictionary to another, using a default value
+// if the string couldn't be read from the first dictionary.
+void CopyStringOrDefault(base::DictionaryValue* to,
+                         const base::DictionaryValue* from, const char* key,
+                         const std::string& default_if_value_missing,
+                         const std::string& default_if_value_not_string) {
+  to->Set(key, base::Value::CreateStringValue(
+      GetStringOrDefault(from, key, default_if_value_missing,
+                         default_if_value_not_string)));
+}
+
 // Copies all policy values from one dictionary to another, using default values
 // when necessary.
 scoped_ptr<base::DictionaryValue> AddDefaultValuesWhenNecessary(
     const base::DictionaryValue* from) {
   scoped_ptr<base::DictionaryValue> to(new base::DictionaryValue());
   CopyBooleanOrDefault(to.get(), from,
                        PolicyWatcher::kNatPolicyName, true, false);
+  CopyStringOrDefault(to.get(), from,
+                      PolicyWatcher::kHostDomainPolicyName, "", "");
   return to.Pass();
 }
 
 }  // namespace
 
 const char PolicyWatcher::kNatPolicyName[] =
     "RemoteAccessHostFirewallTraversal";
 
+const char PolicyWatcher::kHostDomainPolicyName[] =
+    "RemoteAccessHostDomain";
+
 const char* const PolicyWatcher::kBooleanPolicyNames[] =
     { PolicyWatcher::kNatPolicyName };
 
 const int PolicyWatcher::kBooleanPolicyNamesNum =
     arraysize(kBooleanPolicyNames);
 
+const char* const PolicyWatcher::kStringPolicyNames[] =
+    { PolicyWatcher::kHostDomainPolicyName };
+
+const int PolicyWatcher::kStringPolicyNamesNum =
+    arraysize(kStringPolicyNames);
+
 PolicyWatcher::PolicyWatcher(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : task_runner_(task_runner),
       old_policies_(new base::DictionaryValue()),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 PolicyWatcher::~PolicyWatcher() {
 }
 
@@ 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