Add source column to chrome://policy showing the origins of policies.

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 16 matching lines @@
 #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/policy_types.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;
 using base::UTF16ToUTF8;
 using base::win::RegKey;
 
 namespace policy {
 
@@ skipping 279 matching lines @@
   ASSERT_HRESULT_SUCCEEDED(RegOverridePredefKey(HKEY_CURRENT_USER, 0));
 }
 
 void ScopedGroupPolicyRegistrySandbox::DeleteKeys() {
   RegKey key(HKEY_CURRENT_USER, key_name_.c_str(), KEY_ALL_ACCESS);
   ASSERT_TRUE(key.Valid());
   key.DeleteKey(L"");
 }
 
 RegistryTestHarness::RegistryTestHarness(HKEY hive, PolicyScope scope)
-    : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, scope), hive_(hive) {}
+    : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, scope,
+                                POLICY_SOURCE_PLATFORM),
+      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(
@@ skipping 101 matching lines @@
 PolicyProviderTestHarness* RegistryTestHarness::CreateHKCU() {
   return new RegistryTestHarness(HKEY_CURRENT_USER, POLICY_SCOPE_USER);
 }
 
 // static
 PolicyProviderTestHarness* RegistryTestHarness::CreateHKLM() {
   return new RegistryTestHarness(HKEY_LOCAL_MACHINE, POLICY_SCOPE_MACHINE);
 }
 
 PRegTestHarness::PRegTestHarness()
-    : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE) {}
+    : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+                                POLICY_SOURCE_PLATFORM) {
+}
 
 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(base::WriteFile(preg_file_path_,
                                    preg_parser::kPRegFileHeader,
                                    arraysize(preg_parser::kPRegFileHeader)));
@@ skipping 282 matching lines @@
     hklm_key.WriteValue(
         UTF8ToUTF16(test_keys::kKeyString).c_str(),
         UTF8ToUTF16("registry").c_str());
   }
 
   bool MatchesRegistrySentinel() {
     base::DictionaryValue expected_policy;
     expected_policy.SetString(test_keys::kKeyString, "registry");
     PolicyBundle expected;
     expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
-        .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+        .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+                  POLICY_SOURCE_PLATFORM);
     return Matches(expected);
   }
 
   bool MatchesTestBundle() {
     base::DictionaryValue expected_policy;
     expected_policy.SetBoolean(test_keys::kKeyBoolean, true);
     expected_policy.SetString(test_keys::kKeyString, "GPO");
     expected_policy.SetInteger(test_keys::kKeyInteger, 42);
     scoped_ptr<base::ListValue> list(new base::ListValue());
     list->AppendString("GPO 1");
     list->AppendString("GPO 2");
     expected_policy.Set(test_keys::kKeyStringList, list.release());
     PolicyBundle expected;
     expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
         .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY,
-                  POLICY_SCOPE_MACHINE);
+                  POLICY_SCOPE_MACHINE, POLICY_SOURCE_PLATFORM);
     return Matches(expected);
   }
 
   ScopedGroupPolicyRegistrySandbox registry_sandbox_;
   PGROUP_POLICY_OBJECT gpo_list_;
   DWORD gpo_list_status_;
   base::FilePath test_data_dir_;
   AppliedGPOListProvider* gpo_list_provider_;
 };
 
 const base::char16 PolicyLoaderWinTest::kTestPolicyKey[] =
     L"SOFTWARE\\Policies\\Chromium";
 
 TEST_F(PolicyLoaderWinTest, HKLMOverHKCU) {
   RegKey hklm_key(HKEY_LOCAL_MACHINE, kTestPolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(hklm_key.Valid());
   hklm_key.WriteValue(UTF8ToUTF16(test_keys::kKeyString).c_str(),
                       UTF8ToUTF16("hklm").c_str());
   RegKey hkcu_key(HKEY_CURRENT_USER, kTestPolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(hkcu_key.Valid());
   hkcu_key.WriteValue(UTF8ToUTF16(test_keys::kKeyString).c_str(),
                       UTF8ToUTF16("hkcu").c_str());
 
   PolicyBundle expected;
   expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .Set(test_keys::kKeyString,
            POLICY_LEVEL_MANDATORY,
            POLICY_SCOPE_MACHINE,
+           POLICY_SOURCE_PLATFORM,
            new base::StringValue("hklm"),
            NULL);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, Merge3rdPartyPolicies) {
   // Policy for the same extension will be provided at the 4 level/scope
   // combinations, to verify that they overlap as expected.
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "merge");
   ASSERT_TRUE(RegisterSchema(
@@ skipping 34 matching lines @@
   policy.SetString("c", kUserRecommended);
   policy.SetString("d", kUserRecommended);
   EXPECT_TRUE(InstallValue(policy, HKEY_CURRENT_USER,
                            kPathSuffix, kRecommended));
 
   PolicyBundle expected;
   PolicyMap& expected_policy = expected.Get(ns);
   expected_policy.Set("a",
                       POLICY_LEVEL_MANDATORY,
                       POLICY_SCOPE_MACHINE,
+                      POLICY_SOURCE_PLATFORM,
                       new base::StringValue(kMachineMandatory),
                       NULL);
   expected_policy.Set("b",
                       POLICY_LEVEL_MANDATORY,
                       POLICY_SCOPE_USER,
+                      POLICY_SOURCE_PLATFORM,
                       new base::StringValue(kUserMandatory),
                       NULL);
   expected_policy.Set("c",
                       POLICY_LEVEL_RECOMMENDED,
                       POLICY_SCOPE_MACHINE,
+                      POLICY_SOURCE_PLATFORM,
                       new base::StringValue(kMachineRecommended),
                       NULL);
   expected_policy.Set("d",
                       POLICY_LEVEL_RECOMMENDED,
                       POLICY_SCOPE_USER,
+                      POLICY_SOURCE_PLATFORM,
                       new base::StringValue(kUserRecommended),
                       NULL);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, LoadStringEncodedValues) {
   // Create a dictionary with all the types that can be stored encoded in a
   // string.
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "string");
   ASSERT_TRUE(RegisterSchema(
@@ skipping 38 matching lines @@
   encoded_policy.SetString("double", "456.78e9");
   encoded_policy.SetString("list", encoded_list);
   encoded_policy.SetString("dict", encoded_dict);
 
   const base::string16 kPathSuffix =
       kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions\\string");
   EXPECT_TRUE(
       InstallValue(encoded_policy, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
 
   PolicyBundle expected;
-  expected.Get(ns).LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+  expected.Get(ns).LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+                            POLICY_SOURCE_PLATFORM);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, LoadIntegerEncodedValues) {
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "int");
   ASSERT_TRUE(RegisterSchema(
       ns,
       "{"
       "  \"type\": \"object\","
       "  \"properties\": {"
@@ skipping 11 matching lines @@
   const base::string16 kPathSuffix =
       kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions\\int");
   EXPECT_TRUE(
       InstallValue(encoded_policy, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
 
   base::DictionaryValue policy;
   policy.SetBoolean("bool", true);
   policy.SetInteger("int", 123);
   policy.SetDouble("double", 456.0);
   PolicyBundle expected;
-  expected.Get(ns).LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+  expected.Get(ns).LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+                            POLICY_SOURCE_PLATFORM);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, DefaultPropertySchemaType) {
   // Build a schema for an "object" with a default schema for its properties.
   // Note that the top-level object can't have "additionalProperties", so
   // a "policy" property is used instead.
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "test");
   ASSERT_TRUE(RegisterSchema(
       ns,
@@ skipping 29 matching lines @@
       InstallValue(all_policies, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
 
   base::DictionaryValue expected_policy;
   expected_policy.SetInteger("special-int1", 123);
   expected_policy.SetInteger("special-int2", -456);
   expected_policy.SetDouble("double1", 789.0);
   expected_policy.SetDouble("double2", 123.456e7);
   base::DictionaryValue expected_policies;
   expected_policies.Set("policy", expected_policy.DeepCopy());
   PolicyBundle expected;
-  expected.Get(ns).LoadFrom(
-      &expected_policies, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+  expected.Get(ns).LoadFrom(&expected_policies, POLICY_LEVEL_MANDATORY,
+                            POLICY_SCOPE_USER, POLICY_SOURCE_PLATFORM);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, AppliedPolicyNotPresent) {
   InstallRegistrySentinel();
   gpo_list_ = NULL;
   gpo_list_status_ = ERROR_SUCCESS;
 
   PolicyBundle empty;
   EXPECT_TRUE(Matches(empty));
@@ skipping 144 matching lines @@
       POLICY_DOMAIN_EXTENSIONS, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
   const PolicyNamespace ns_b(
       POLICY_DOMAIN_EXTENSIONS, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
   ASSERT_TRUE(RegisterSchema(ns_a, kTestSchema));
   ASSERT_TRUE(RegisterSchema(ns_b, kTestSchema));
 
   PolicyBundle expected;
   base::DictionaryValue expected_a;
   expected_a.SetInteger("policy 1", 3);
   expected_a.SetInteger("policy 2", 3);
-  expected.Get(ns_a).LoadFrom(
-      &expected_a, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
+  expected.Get(ns_a).LoadFrom(&expected_a, POLICY_LEVEL_MANDATORY,
+                              POLICY_SCOPE_MACHINE, POLICY_SOURCE_PLATFORM);
   base::DictionaryValue expected_b;
   expected_b.SetInteger("policy 1", 2);
-  expected.Get(ns_b).LoadFrom(
-      &expected_b, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
+  expected.Get(ns_b).LoadFrom(&expected_b, POLICY_LEVEL_MANDATORY,
+                              POLICY_SCOPE_MACHINE, POLICY_SOURCE_PLATFORM);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, LBSSupport) {
   const PolicyNamespace ns(
       POLICY_DOMAIN_EXTENSIONS, "heildphpnddilhkemkielfhnkaagiabh");
   schema_registry_.RegisterComponent(ns, Schema());
 
   const char kIncompleteSchema[] =
       "{"
@@ skipping 15 matching lines @@
   base::DictionaryValue root;
   root.Set(base::UTF16ToUTF8(kMandatory), policy.DeepCopy());
   root.SetString(kSchema, kIncompleteSchema);
   EXPECT_TRUE(InstallValue(root, HKEY_LOCAL_MACHINE,
                            kPathSuffix, base::ASCIIToUTF16(ns.component_id)));
 
   PolicyBundle expected;
   PolicyMap& expected_policy = expected.Get(ns);
   expected_policy.Set("alternative_browser_path",
                       POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+                      POLICY_SOURCE_PLATFORM,
                       new base::StringValue("c:\\legacy\\browser.exe"), NULL);
   expected_policy.Set("url_list", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-                      list.DeepCopy(), NULL);
+                      POLICY_SOURCE_PLATFORM, list.DeepCopy(), nullptr);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy