Refactor the windows policy provider to use AsynchronousPolicyProvider.

chrome/browser/policy/configuration_policy_provider_win_unittest.cc

 // Copyright (c) 2010 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 <gtest/gtest.h>
-
 #include <windows.h>
 
+#include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
+#include "chrome/browser/browser_thread.h"
+#include "chrome/browser/policy/asynchronous_policy_loader.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/configuration_policy_provider_win.h"
 #include "chrome/browser/policy/mock_configuration_policy_store.h"
 #include "chrome/common/policy_constants.h"
 #include "chrome/common/pref_names.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::win::RegKey;
 
 namespace policy {
@@ skipping 119 matching lines @@
 
   // Write the given value to the registry.
   void WriteValue(HKEY hive, const char* name, const Value* value);
   // Write a value that is not compatible with the given |value|.
   void WriteInvalidValue(HKEY hive, const char* name, const Value* value);
 
  protected:
   scoped_ptr<MockConfigurationPolicyStore> store_;
   scoped_ptr<ConfigurationPolicyProviderWin> provider_;
 
- private:
   // A message loop must be declared and instantiated for these tests,
   // because Windows policy provider create WaitableEvents and
   // ObjectWatchers that require the tests to have a MessageLoop associated
   // with the thread executing the tests.
   MessageLoop loop_;
 
+ private:
+  BrowserThread ui_thread_;
+  BrowserThread file_thread_;
+
   // Keys are created for the lifetime of a test to contain
   // the sandboxed HKCU and HKLM hives, respectively.
   RegKey temp_hkcu_hive_key_;
   RegKey temp_hklm_hive_key_;
 };
 
 ConfigurationPolicyProviderWinTest::ConfigurationPolicyProviderWinTest()
-    : temp_hklm_hive_key_(HKEY_CURRENT_USER, kUnitTestMachineOverrideSubKey,
+    : ui_thread_(BrowserThread::UI, &loop_),
+      file_thread_(BrowserThread::FILE, &loop_),
+      temp_hklm_hive_key_(HKEY_CURRENT_USER, kUnitTestMachineOverrideSubKey,
                           KEY_READ),
       temp_hkcu_hive_key_(HKEY_CURRENT_USER, kUnitTestUserOverrideSubKey,
                           KEY_READ) {
 }
 
 void ConfigurationPolicyProviderWinTest::SetUp() {
   // Cleanup any remnants of previous tests.
   DeleteRegistrySandbox();
 
   // Create the subkeys to hold the overridden HKLM and HKCU
   // policy settings.
   temp_hklm_hive_key_.Create(HKEY_CURRENT_USER,
                              kUnitTestMachineOverrideSubKey,
                              KEY_ALL_ACCESS);
   temp_hkcu_hive_key_.Create(HKEY_CURRENT_USER,
                              kUnitTestUserOverrideSubKey,
                              KEY_ALL_ACCESS);
 
   ActivateOverrides();
 
   store_.reset(new MockConfigurationPolicyStore);
   provider_.reset(new ConfigurationPolicyProviderWin(
       ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList()));
 }
 
 void ConfigurationPolicyProviderWinTest::TearDown() {
   DeactivateOverrides();
   DeleteRegistrySandbox();
+  loop_.RunAllPending();
 }
 
 void ConfigurationPolicyProviderWinTest::ActivateOverrides() {
   HRESULT result = RegOverridePredefKey(HKEY_LOCAL_MACHINE,
                                         temp_hklm_hive_key_.Handle());
   EXPECT_EQ(ERROR_SUCCESS, result);
   result = RegOverridePredefKey(HKEY_CURRENT_USER,
                                 temp_hkcu_hive_key_.Handle());
   EXPECT_EQ(ERROR_SUCCESS, result);
 }
@@ skipping 85 matching lines @@
   EXPECT_TRUE(store_->policy_map().empty());
 }
 
 TEST_P(ConfigurationPolicyProviderWinTest, InvalidValue) {
   WriteInvalidValue(HKEY_LOCAL_MACHINE,
                     GetParam().policy_name(),
                     GetParam().hklm_value());
   WriteInvalidValue(HKEY_CURRENT_USER,
                     GetParam().policy_name(),
                     GetParam().hkcu_value());
+  provider_->loader()->Reload();
+  loop_.RunAllPending();
   provider_->Provide(store_.get());
   EXPECT_TRUE(store_->policy_map().empty());
 }
 
 TEST_P(ConfigurationPolicyProviderWinTest, HKLM) {
   WriteValue(HKEY_LOCAL_MACHINE,
              GetParam().policy_name(),
              GetParam().hklm_value());
+  provider_->loader()->Reload();
+  loop_.RunAllPending();
   provider_->Provide(store_.get());
   const Value* value = store_->Get(GetParam().type());
   ASSERT_TRUE(value);
   EXPECT_TRUE(value->Equals(GetParam().hklm_value()));
 }
 
 TEST_P(ConfigurationPolicyProviderWinTest, HKCU) {
   WriteValue(HKEY_CURRENT_USER,
              GetParam().policy_name(),
              GetParam().hkcu_value());
+  provider_->loader()->Reload();
+  loop_.RunAllPending();
   provider_->Provide(store_.get());
   const Value* value = store_->Get(GetParam().type());
   ASSERT_TRUE(value);
   EXPECT_TRUE(value->Equals(GetParam().hkcu_value()));
 }
 
 TEST_P(ConfigurationPolicyProviderWinTest, HKLMOverHKCU) {
   WriteValue(HKEY_LOCAL_MACHINE,
              GetParam().policy_name(),
              GetParam().hklm_value());
   WriteValue(HKEY_CURRENT_USER,
              GetParam().policy_name(),
              GetParam().hkcu_value());
+  provider_->loader()->Reload();
+  loop_.RunAllPending();
   provider_->Provide(store_.get());
   const Value* value = store_->Get(GetParam().type());
   ASSERT_TRUE(value);
   EXPECT_TRUE(value->Equals(GetParam().hklm_value()));
 }
 
 // Instantiate the test case for all supported policies.
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyProviderWinTestInstance,
     ConfigurationPolicyProviderWinTest,
@@ skipping 80 matching lines @@
             kPolicyExtensionInstallDenyList,
             key::kExtensionInstallDenyList),
         PolicyTestParams::ForBooleanPolicy(
             kPolicyShowHomeButton,
             key::kShowHomeButton),
         PolicyTestParams::ForBooleanPolicy(
             kPolicyPrintingEnabled,
             key::kPrintingEnabled)));
 
 }  // namespace policy