Implement the windows policy provider based on the AsyncPolicyLoader.

chrome/browser/policy/policy_loader_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.
 
-#include "chrome/browser/policy/configuration_policy_provider_delegate_win.h"
+#include "chrome/browser/policy/policy_loader_win.h"
 
 #include <string>
 
 #include <string.h>
 
+#include <userenv.h>
+
+// userenv.dll is required for RegisterGPNotification().
+#pragma comment(lib, "userenv.lib")
+
 #include "base/basictypes.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/win/registry.h"
 #include "chrome/browser/policy/policy_bundle.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 
 using base::win::RegKey;
 
@@ skipping 171 matching lines @@
   if (!LoadHighestPriorityKey(string16(), name, &key, level, scope))
     return NULL;
   string16 value;
   if (!ReadRegistryString(&key, name, &value))
     return NULL;
   return base::JSONReader::Read(UTF16ToUTF8(value));
 }
 
 }  // namespace
 
-ConfigurationPolicyProviderDelegateWin::ConfigurationPolicyProviderDelegateWin(
-    const PolicyDefinitionList* policy_definition_list)
-    : policy_definition_list_(policy_definition_list) {}
+WinPolicyLoader::WinPolicyLoader(const PolicyDefinitionList* policy_list)
+    : is_initialized_(false),
+      policy_list_(policy_list),
+      user_policy_changed_event_(false, false),
+      machine_policy_changed_event_(false, false),
+      user_policy_watcher_failed_(false),

[Mattias Nissler (ping if slow), 2012/06/04 09:29:41]

the failed_ fields are no longer used AFAICS

[Joao da Silva, 2012/06/06 13:05:24]

They're used in SetupWatches() to stop trying to install the watches if it
failed before.

+      machine_policy_watcher_failed_(false) {
+  if (!RegisterGPNotification(user_policy_changed_event_.handle(), false)) {
+    DPLOG(WARNING) << "Failed to register user group policy notification";
+    user_policy_watcher_failed_ = true;
+  }
+  if (!RegisterGPNotification(machine_policy_changed_event_.handle(), true)) {
+    DPLOG(WARNING) << "Failed to register machine group policy notification.";
+    machine_policy_watcher_failed_ = true;
+  }
+}
 
-scoped_ptr<PolicyBundle> ConfigurationPolicyProviderDelegateWin::Load() {
+WinPolicyLoader::~WinPolicyLoader() {
+  user_policy_watcher_.StopWatching();
+  machine_policy_watcher_.StopWatching();
+}
+
+// static
+AsyncPolicyProvider* WinPolicyLoader::CreateProvider(
+    const PolicyDefinitionList* policy_list) {
+  WinPolicyLoader* loader = new WinPolicyLoader(policy_list);
+  return new AsyncPolicyProvider(policy_list, loader);
+}
+
+void WinPolicyLoader::InitOnFile() {
+  is_initialized_ = true;
+  SetupWatches();
+}
+
+scoped_ptr<PolicyBundle> WinPolicyLoader::Load() {
+  // Reset the watches BEFORE reading the individual policies to avoid
+  // missing a change notification.
+  if (is_initialized_)
+    SetupWatches();
+
   scoped_ptr<PolicyBundle> bundle(new PolicyBundle());
   PolicyMap& chrome_policy = bundle->Get(POLICY_DOMAIN_CHROME, std::string());
 
   const PolicyDefinitionList::Entry* current;
-  for (current = policy_definition_list_->begin;
-       current != policy_definition_list_->end;
-       ++current) {
+  for (current = policy_list_->begin; current != policy_list_->end; ++current) {
     const string16 name(ASCIIToUTF16(current->name));
     PolicyLevel level = POLICY_LEVEL_MANDATORY;
     PolicyScope scope = POLICY_SCOPE_MACHINE;
     Value* value = NULL;
 
     switch (current->value_type) {
       case Value::TYPE_STRING:
         value = ReadStringValue(name, &level, &scope);
         break;
 
@@ skipping 17 matching lines @@
         NOTREACHED();
     }
 
     if (value)
       chrome_policy.Set(current->name, level, scope, value);
   }
 
   return bundle.Pass();
 }
 
+void WinPolicyLoader::SetupWatches() {
+  DCHECK(is_initialized_);
+  if (!user_policy_watcher_failed_ &&
+      !user_policy_watcher_.GetWatchedObject() &&
+      !user_policy_watcher_.StartWatching(
+          user_policy_changed_event_.handle(), this)) {
+    DLOG(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)) {
+    DLOG(WARNING) << "Failed to start watch for machine policy change event";
+    machine_policy_watcher_failed_ = true;
+  }
+}
+
+void WinPolicyLoader::OnObjectSignaled(HANDLE object) {
+  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(false);
+}
+
 }  // namespace policy