On enterprise machines read policy from the registry.

components/policy/core/common/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 "components/policy/core/common/policy_loader_win.h"
 
 #include <windows.h>
 #include <userenv.h>
 
 #include <algorithm>
@@ skipping 10 matching lines @@
 #include "base/json/json_writer.h"
 #include "base/path_service.h"
 #include "base/process/process.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/win/registry.h"
+#include "base/win/win_util.h"
 #include "components/policy/core/common/async_policy_provider.h"
 #include "components/policy/core/common/configuration_policy_provider_test.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/preg_parser_win.h"
 #include "components/policy/core/common/schema_map.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::UTF8ToUTF16;
@@ skipping 298 matching lines @@
 RegistryTestHarness::RegistryTestHarness(HKEY hive, PolicyScope scope)
     : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, scope), hive_(hive) {}
 
 RegistryTestHarness::~RegistryTestHarness() {}
 
 void RegistryTestHarness::SetUp() {}
 
 ConfigurationPolicyProvider* RegistryTestHarness::CreateProvider(
     SchemaRegistry* registry,
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
+  base::win::SetDomainStateForTesting(true);
   scoped_ptr<AsyncPolicyLoader> loader(
       new PolicyLoaderWin(task_runner, kTestPolicyKey, this));
   return new AsyncPolicyProvider(registry, loader.Pass());
 }
 
 void RegistryTestHarness::InstallEmptyPolicy() {}
 
 void RegistryTestHarness::InstallStringPolicy(
     const std::string& policy_name,
     const std::string& policy_value) {
@@ skipping 97 matching lines @@
 PolicyProviderTestHarness* RegistryTestHarness::CreateHKLM() {
   return new RegistryTestHarness(HKEY_LOCAL_MACHINE, POLICY_SCOPE_MACHINE);
 }
 
 PRegTestHarness::PRegTestHarness()
     : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE) {}
 
 PRegTestHarness::~PRegTestHarness() {}
 
 void PRegTestHarness::SetUp() {
+  base::win::SetDomainStateForTesting(false);
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   preg_file_path_ = temp_dir_.path().Append(PolicyLoaderWin::kPRegFileName);
   ASSERT_TRUE(file_util::WriteFile(preg_file_path_,
                                    preg_parser::kPRegFileHeader,
                                    arraysize(preg_parser::kPRegFileHeader)));
 
   memset(&gpo_, 0, sizeof(GROUP_POLICY_OBJECT));
   gpo_.lpFileSysPath = const_cast<wchar_t*>(temp_dir_.path().value().c_str());
 }
 
@@ skipping 219 matching lines @@
   // The policy key this tests places data under. This must match the data
   // files in chrome/test/data/policy/gpo.
   static const base::char16 kTestPolicyKey[];
 
   PolicyLoaderWinTest()
       : gpo_list_(NULL),
         gpo_list_status_(ERROR_ACCESS_DENIED) {}
   virtual ~PolicyLoaderWinTest() {}
 
   virtual void SetUp() OVERRIDE {
+    base::win::SetDomainStateForTesting(false);
     PolicyTestBase::SetUp();
 
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &test_data_dir_));
     test_data_dir_ = test_data_dir_.AppendASCII("chrome")
                                    .AppendASCII("test")
                                    .AppendASCII("data")
                                    .AppendASCII("policy")
                                    .AppendASCII("gpo");
   }
 
@@ skipping 302 matching lines @@
   base::FilePath gpo_dir(test_data_dir_.AppendASCII("empty"));
   GROUP_POLICY_OBJECT gpo;
   InitGPO(&gpo, 0, gpo_dir, NULL, NULL);
   gpo_list_ = &gpo;
   gpo_list_status_ = ERROR_SUCCESS;
 
   PolicyBundle empty;
   EXPECT_TRUE(Matches(empty));
 }
 
+TEST_F(PolicyLoaderWinTest, AppliedPolicyInDomain) {
+  base::win::SetDomainStateForTesting(true);
+  InstallRegistrySentinel();
+  base::FilePath gpo_dir(test_data_dir_.AppendASCII("empty"));
+  GROUP_POLICY_OBJECT gpo;
+  InitGPO(&gpo, 0, gpo_dir, NULL, NULL);
+  gpo_list_ = &gpo;
+  gpo_list_status_ = ERROR_SUCCESS;
+
+  PolicyBundle empty;
+  EXPECT_TRUE(MatchesRegistrySentinel());
+}
+
 TEST_F(PolicyLoaderWinTest, AppliedPolicyNonExistingFile) {
   InstallRegistrySentinel();
   GROUP_POLICY_OBJECT gpo;
   InitGPO(&gpo, 0, test_data_dir_, NULL, NULL);
   gpo_list_ = &gpo;
   gpo_list_status_ = ERROR_SUCCESS;
 
   EXPECT_TRUE(MatchesRegistrySentinel());
 }
 
@@ skipping 143 matching lines @@
   PolicyMap& expected_policy = expected.Get(ns);
   expected_policy.Set("alternative_browser_path",
                       POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       new base::StringValue("c:\\legacy\\browser.exe"), NULL);
   expected_policy.Set("url_list", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       list.DeepCopy(), NULL);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy