[Chromoting] Let the Windows host policy watcher read string-valued policies.

remoting/host/policy_hack/policy_watcher_win.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 various classes in
 // src/chrome/browser/policy. In particular, look at
 //
 //   configuration_policy_provider_delegate_win.{h,cc}
 //   configuration_policy_loader_win.{h,cc}
 //
@@ skipping 94 matching lines @@
             machine_policy_changed_event_.handle(), this)) {
       LOG(WARNING) << "Failed to start watch for machine policy change event";
       machine_policy_watcher_failed_ = true;
      }
 
     if (user_policy_watcher_failed_ || machine_policy_watcher_failed_) {
       ScheduleFallbackReloadTask();
     }
   }
 
-  bool GetRegistryPolicyInteger(const string16& value_name,
+  bool GetRegistryPolicyString(const std::string& value_name,
+                               std::string* result) const {
+    std::wstring value_name_wide = UTF8ToWide(value_name);
+    std::wstring value;
+    RegKey policy_key(HKEY_LOCAL_MACHINE, kRegistrySubKey, KEY_READ);
+    if (policy_key.ReadValue(value_name_wide.c_str(), &value) ==
+        ERROR_SUCCESS) {
+      *result = WideToUTF8(value);
+      return true;
+    }
+
+    if (policy_key.Open(HKEY_CURRENT_USER, kRegistrySubKey, KEY_READ) ==
+      ERROR_SUCCESS) {
+      if (policy_key.ReadValue(value_name_wide.c_str(), &value) ==
+          ERROR_SUCCESS) {
+        *result = WideToUTF8(value);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool GetRegistryPolicyInteger(const std::string& value_name,
                                 uint32* result) const {
+    std::wstring value_name_wide = UTF8ToWide(value_name);
     DWORD value = 0;
     RegKey policy_key(HKEY_LOCAL_MACHINE, kRegistrySubKey, KEY_READ);
-    if (policy_key.ReadValueDW(value_name.c_str(), &value) == ERROR_SUCCESS) {
+    if (policy_key.ReadValueDW(value_name_wide.c_str(), &value) ==
+        ERROR_SUCCESS) {
       *result = value;
       return true;
     }
 
     if (policy_key.Open(HKEY_CURRENT_USER, kRegistrySubKey, KEY_READ) ==
         ERROR_SUCCESS) {
-      if (policy_key.ReadValueDW(value_name.c_str(), &value) == ERROR_SUCCESS) {
+      if (policy_key.ReadValueDW(value_name_wide.c_str(), &value) ==
+          ERROR_SUCCESS) {
         *result = value;
         return true;
       }
     }
     return false;
   }
 
-  bool GetRegistryPolicyBoolean(const string16& value_name,
+  bool GetRegistryPolicyBoolean(const std::string& value_name,
                                 bool* result) const {
     uint32 local_result = 0;
     bool ret = GetRegistryPolicyInteger(value_name, &local_result);
     if (ret)
       *result = local_result != 0;
     return ret;
   }
 
   base::DictionaryValue* Load() {
     base::DictionaryValue* policy = new base::DictionaryValue();
 
     for (int i = 0; i < kBooleanPolicyNamesNum; ++i) {
       const char* policy_name = kBooleanPolicyNames[i];
       bool bool_value;
-      const string16 name(ASCIIToUTF16(policy_name));
-      if (GetRegistryPolicyBoolean(name, &bool_value)) {
+      if (GetRegistryPolicyBoolean(policy_name, &bool_value)) {
         policy->SetBoolean(policy_name, bool_value);
       }
     }
-    // TODO(simonmorris): Read policies whose names are in kStringPolicyNames.
-
+    for (int i = 0; i < kStringPolicyNamesNum; ++i) {
+      const char* policy_name = kStringPolicyNames[i];
+      std::string string_value;
+      if (GetRegistryPolicyString(policy_name, &string_value)) {
+        policy->SetString(policy_name, string_value);
+      }
+    }
     return policy;
   }
 
   // Post a reload notification and update the watch machinery.
   void Reload() {
     DCHECK(OnPolicyWatcherThread());
     SetupWatches();
     scoped_ptr<DictionaryValue> new_policy(Load());
     UpdatePolicies(new_policy.get());
   }
@@ skipping 16 matching lines @@
   bool machine_policy_watcher_failed_;
 };
 
 PolicyWatcher* PolicyWatcher::Create(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   return new PolicyWatcherWin(task_runner);
 }
 
 }  // namespace policy_hack
 }  // namespace remoting