Implement the windows policy provider based on the AsyncPolicyLoader.

chrome/browser/policy/policy_loader_win_unittest.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 <gtest/gtest.h>
+#include "chrome/browser/policy/policy_loader_win.h"
+
 #include <windows.h>
 
 #include "base/json/json_writer.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
-#include "chrome/browser/policy/asynchronous_policy_test_base.h"
+#include "chrome/browser/policy/async_policy_provider.h"
 #include "chrome/browser/policy/configuration_policy_provider_test.h"
-#include "chrome/browser/policy/configuration_policy_provider_win.h"
 #include "chrome/browser/policy/policy_bundle.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::win::RegKey;
 
 namespace policy {
 
 namespace {
@@ skipping 107 matching lines @@
 }
 
 TestHarness::TestHarness(HKEY hive, PolicyScope scope)
     : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, scope), hive_(hive) {}
 
 TestHarness::~TestHarness() {}
 
 void TestHarness::SetUp() {}
 
 ConfigurationPolicyProvider* TestHarness::CreateProvider(
-    const PolicyDefinitionList* policy_definition_list) {
-  return new ConfigurationPolicyProviderWin(policy_definition_list);
+    const PolicyDefinitionList* policy_list) {
+  scoped_ptr<AsyncPolicyLoader> loader(new PolicyLoaderWin(policy_list));
+  return new AsyncPolicyProvider(policy_list, loader.Pass());
 }
 
 void TestHarness::InstallEmptyPolicy() {}
 
 void TestHarness::InstallStringPolicy(const std::string& policy_name,
                                       const std::string& policy_value) {
   RegKey key(hive_, policy::kRegistryMandatorySubKey, KEY_ALL_ACCESS);
   key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
                  UTF8ToUTF16(policy_value).c_str());
 }
@@ skipping 48 matching lines @@
 
 // static
 PolicyProviderTestHarness* TestHarness::CreateHKLM() {
   return new TestHarness(HKEY_LOCAL_MACHINE, POLICY_SCOPE_MACHINE);
 }
 
 }  // namespace
 
 // Instantiate abstract test case for basic policy reading tests.
 INSTANTIATE_TEST_CASE_P(
-    ConfigurationPolicyProviderWinTest,
+    PolicyProviderWinTest,
     ConfigurationPolicyProviderTest,
     testing::Values(TestHarness::CreateHKCU, TestHarness::CreateHKLM));
 
 // Test cases for windows policy provider specific functionality.
-class ConfigurationPolicyProviderWinTest : public AsynchronousPolicyTestBase {
+class PolicyLoaderWinTest : public PolicyTestBase {
  protected:
-  ConfigurationPolicyProviderWinTest()
-      : provider_(&test_policy_definitions::kList) {}
-  virtual ~ConfigurationPolicyProviderWinTest() {}
+  PolicyLoaderWinTest() {}
+  virtual ~PolicyLoaderWinTest() {}
 
   ScopedGroupPolicyRegistrySandbox registry_sandbox_;
-  ConfigurationPolicyProviderWin provider_;
 };
 
-TEST_F(ConfigurationPolicyProviderWinTest, HKLMOverHKCU) {
+TEST_F(PolicyLoaderWinTest, HKLMOverHKCU) {
   RegKey hklm_key(HKEY_LOCAL_MACHINE,
                   policy::kRegistryMandatorySubKey,
                   KEY_ALL_ACCESS);
   hklm_key.WriteValue(UTF8ToUTF16(test_policy_definitions::kKeyString).c_str(),
                       UTF8ToUTF16("hklm").c_str());
   RegKey hkcu_key(HKEY_CURRENT_USER,
                   policy::kRegistryMandatorySubKey,
                   KEY_ALL_ACCESS);
   hkcu_key.WriteValue(UTF8ToUTF16(test_policy_definitions::kKeyString).c_str(),
                       UTF8ToUTF16("hkcu").c_str());
 
-  provider_.RefreshPolicies();
-  loop_.RunAllPending();
+  PolicyLoaderWin loader(&test_policy_definitions::kList);
+  scoped_ptr<PolicyBundle> bundle(loader.Load());
 
   PolicyBundle expected_bundle;
   expected_bundle.Get(POLICY_DOMAIN_CHROME, "")
       .Set(test_policy_definitions::kKeyString,
            POLICY_LEVEL_MANDATORY,
            POLICY_SCOPE_MACHINE,
            base::Value::CreateStringValue("hklm"));
-  EXPECT_TRUE(provider_.policies().Equals(expected_bundle));
+  EXPECT_TRUE(bundle->Equals(expected_bundle));
 }
 
 }  // namespace policy