Using PolicyServiceWatcher instead of PolicyWatcherLinux/Win/Mac.

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}
-//
-// This is a reduction of the functionality in those classes.
-
-#include "remoting/host/policy_hack/policy_watcher.h"
-
-#include <userenv.h>
-
-#include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop_proxy.h"
-#include "base/strings/string16.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/values.h"
-#include "base/win/object_watcher.h"
-#include "base/win/registry.h"
-
-// userenv.dll is required for RegisterGPNotification().
-#pragma comment(lib, "userenv.lib")
-
-using base::win::RegKey;
-
-namespace remoting {
-namespace policy_hack {
-
-namespace {
-
-const wchar_t kRegistrySubKey[] = L"SOFTWARE\\Policies\\Google\\Chrome";
-
-}  // namespace
-
-class PolicyWatcherWin :
-  public PolicyWatcher,
-  public base::win::ObjectWatcher::Delegate {
- public:
-  explicit PolicyWatcherWin(
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-      : PolicyWatcher(task_runner),
-        user_policy_changed_event_(false, false),
-        machine_policy_changed_event_(false, false),
-        user_policy_watcher_failed_(false),
-        machine_policy_watcher_failed_(false) {
-  }
-
-  virtual ~PolicyWatcherWin() {
-  }
-
-  virtual void StartWatchingInternal() override {
-    DCHECK(OnPolicyWatcherThread());
-
-    if (!RegisterGPNotification(user_policy_changed_event_.handle(), false)) {
-      PLOG(WARNING) << "Failed to register user group policy notification";
-      user_policy_watcher_failed_ = true;
-    }
-
-    if (!RegisterGPNotification(machine_policy_changed_event_.handle(), true)) {
-      PLOG(WARNING) << "Failed to register machine group policy notification.";
-      machine_policy_watcher_failed_ = true;
-    }
-
-    Reload();
-  }
-
-  virtual void StopWatchingInternal() override {
-    DCHECK(OnPolicyWatcherThread());
-
-    if (!UnregisterGPNotification(user_policy_changed_event_.handle())) {
-      PLOG(WARNING) << "Failed to unregister user group policy notification";
-    }
-
-    if (!UnregisterGPNotification(machine_policy_changed_event_.handle())) {
-      PLOG(WARNING) <<
-          "Failed to unregister machine group policy notification.";
-    }
-
-    user_policy_watcher_.StopWatching();
-    machine_policy_watcher_.StopWatching();
-  }
-
- private:
-  // Updates the watchers and schedules the reload task if appropriate.
-  void SetupWatches() {
-    DCHECK(OnPolicyWatcherThread());
-
-    if (!user_policy_watcher_failed_ &&
-        !user_policy_watcher_.GetWatchedObject() &&
-        !user_policy_watcher_.StartWatching(
-            user_policy_changed_event_.handle(), this)) {
-      LOG(WARNING) << "Failed to start watch for user policy change event";
-      user_policy_watcher_failed_ = true;
-    }
-
-    if (!machine_policy_watcher_failed_ &&
-        !machine_policy_watcher_.GetWatchedObject() &&
-        !machine_policy_watcher_.StartWatching(
-            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 GetRegistryPolicyString(const std::string& value_name,
-                               std::string* result) const {
-    // presubmit: allow wstring
-    std::wstring value_name_wide = base::UTF8ToWide(value_name);
-    // presubmit: allow wstring
-    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 = base::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 = base::WideToUTF8(value);
-        return true;
-      }
-    }
-    return false;
-  }
-
-  bool GetRegistryPolicyInteger(const std::string& value_name,
-                                uint32* result) const {
-    // presubmit: allow wstring
-    std::wstring value_name_wide = base::UTF8ToWide(value_name);
-    DWORD value = 0;
-    RegKey policy_key(HKEY_LOCAL_MACHINE, kRegistrySubKey, KEY_READ);
-    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_wide.c_str(), &value) ==
-          ERROR_SUCCESS) {
-        *result = value;
-        return true;
-      }
-    }
-    return false;
-  }
-
-  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;
-  }
-
-  scoped_ptr<base::DictionaryValue> Load() {
-    scoped_ptr<base::DictionaryValue> policy(new base::DictionaryValue());
-
-    for (base::DictionaryValue::Iterator i(Defaults());
-         !i.IsAtEnd(); i.Advance()) {
-      const std::string& policy_name = i.key();
-      if (i.value().GetType() == base::DictionaryValue::TYPE_BOOLEAN) {
-        bool bool_value;
-        if (GetRegistryPolicyBoolean(policy_name, &bool_value)) {
-          policy->SetBoolean(policy_name, bool_value);
-        }
-      }
-      if (i.value().GetType() == base::DictionaryValue::TYPE_STRING) {
-        std::string string_value;
-        if (GetRegistryPolicyString(policy_name, &string_value)) {
-          policy->SetString(policy_name, string_value);
-        }
-      }
-    }
-    return policy.Pass();
-  }
-
-  // Post a reload notification and update the watch machinery.
-  void Reload() {
-    DCHECK(OnPolicyWatcherThread());
-    SetupWatches();
-    scoped_ptr<base::DictionaryValue> new_policy(Load());
-    UpdatePolicies(new_policy.get());
-  }
-
-  // ObjectWatcher::Delegate overrides:
-  virtual void OnObjectSignaled(HANDLE object) {
-    DCHECK(OnPolicyWatcherThread());
-    DCHECK(object == user_policy_changed_event_.handle() ||
-           object == machine_policy_changed_event_.handle())
-        << "unexpected object signaled policy reload, obj = "
-        << std::showbase << std::hex << object;
-    Reload();
-  }
-
-  base::WaitableEvent user_policy_changed_event_;
-  base::WaitableEvent machine_policy_changed_event_;
-  base::win::ObjectWatcher user_policy_watcher_;
-  base::win::ObjectWatcher machine_policy_watcher_;
-  bool user_policy_watcher_failed_;
-  bool machine_policy_watcher_failed_;
-};
-
-scoped_ptr<PolicyWatcher> PolicyWatcher::Create(
-    policy::PolicyService* policy_service,
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  return make_scoped_ptr(new PolicyWatcherWin(task_runner));
-}
-
-}  // namespace policy_hack
-}  // namespace remoting