summaryrefslogtreecommitdiffstats
path: root/chrome/browser/policy
diff options
context:
space:
mode:
Diffstat (limited to 'chrome/browser/policy')
-rw-r--r--chrome/browser/policy/config_dir_policy_loader_unittest.cc83
-rw-r--r--chrome/browser/policy/configuration_policy_provider_test.cc67
-rw-r--r--chrome/browser/policy/configuration_policy_provider_test.h17
-rw-r--r--chrome/browser/policy/policy_loader_mac_unittest.cc3
-rw-r--r--chrome/browser/policy/policy_loader_win.cc368
-rw-r--r--chrome/browser/policy/policy_loader_win.h26
-rw-r--r--chrome/browser/policy/policy_loader_win_unittest.cc366
7 files changed, 758 insertions, 172 deletions
diff --git a/chrome/browser/policy/config_dir_policy_loader_unittest.cc b/chrome/browser/policy/config_dir_policy_loader_unittest.cc
index 6c996d8..a2e7b91 100644
--- a/chrome/browser/policy/config_dir_policy_loader_unittest.cc
+++ b/chrome/browser/policy/config_dir_policy_loader_unittest.cc
@@ -45,6 +45,8 @@ class TestHarness : public PolicyProviderTestHarness {
virtual void InstallDictionaryPolicy(
const std::string& policy_name,
const base::DictionaryValue* policy_value) OVERRIDE;
+ virtual void Install3rdPartyPolicy(
+ const base::DictionaryValue* policies) OVERRIDE;
const FilePath& test_dir() { return test_dir_.path(); }
@@ -52,16 +54,22 @@ class TestHarness : public PolicyProviderTestHarness {
void WriteConfigFile(const base::DictionaryValue& dict,
const std::string& file_name);
+ // Returns a unique name for a policy file. Each subsequent call returns a new
+ // name that comes lexicographically after the previous one.
+ std::string NextConfigFileName();
+
static PolicyProviderTestHarness* Create();
private:
ScopedTempDir test_dir_;
+ int next_policy_file_index_;
DISALLOW_COPY_AND_ASSIGN(TestHarness);
};
TestHarness::TestHarness()
- : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE) {}
+ : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE),
+ next_policy_file_index_(100) {}
TestHarness::~TestHarness() {}
@@ -78,35 +86,35 @@ ConfigurationPolicyProvider* TestHarness::CreateProvider(
void TestHarness::InstallEmptyPolicy() {
base::DictionaryValue dict;
- WriteConfigFile(dict, "policy");
+ WriteConfigFile(dict, NextConfigFileName());
}
void TestHarness::InstallStringPolicy(const std::string& policy_name,
const std::string& policy_value) {
base::DictionaryValue dict;
dict.SetString(policy_name, policy_value);
- WriteConfigFile(dict, "policy");
+ WriteConfigFile(dict, NextConfigFileName());
}
void TestHarness::InstallIntegerPolicy(const std::string& policy_name,
int policy_value) {
base::DictionaryValue dict;
dict.SetInteger(policy_name, policy_value);
- WriteConfigFile(dict, "policy");
+ WriteConfigFile(dict, NextConfigFileName());
}
void TestHarness::InstallBooleanPolicy(const std::string& policy_name,
bool policy_value) {
base::DictionaryValue dict;
dict.SetBoolean(policy_name, policy_value);
- WriteConfigFile(dict, "policy");
+ WriteConfigFile(dict, NextConfigFileName());
}
void TestHarness::InstallStringListPolicy(const std::string& policy_name,
const base::ListValue* policy_value) {
base::DictionaryValue dict;
dict.Set(policy_name, policy_value->DeepCopy());
- WriteConfigFile(dict, "policy");
+ WriteConfigFile(dict, NextConfigFileName());
}
void TestHarness::InstallDictionaryPolicy(
@@ -114,7 +122,13 @@ void TestHarness::InstallDictionaryPolicy(
const base::DictionaryValue* policy_value) {
base::DictionaryValue dict;
dict.Set(policy_name, policy_value->DeepCopy());
- WriteConfigFile(dict, "policy");
+ WriteConfigFile(dict, NextConfigFileName());
+}
+
+void TestHarness::Install3rdPartyPolicy(const base::DictionaryValue* policies) {
+ base::DictionaryValue dict;
+ dict.Set("3rdparty", policies->DeepCopy());
+ WriteConfigFile(dict, NextConfigFileName());
}
void TestHarness::WriteConfigFile(const base::DictionaryValue& dict,
@@ -129,6 +143,11 @@ void TestHarness::WriteConfigFile(const base::DictionaryValue& dict,
file_util::WriteFile(file_path, data.c_str(), data.size()));
}
+std::string TestHarness::NextConfigFileName() {
+ EXPECT_LE(next_policy_file_index_, 999);
+ return std::string("policy") + base::IntToString(next_policy_file_index_++);
+}
+
// static
PolicyProviderTestHarness* TestHarness::Create() {
return new TestHarness();
@@ -142,6 +161,12 @@ INSTANTIATE_TEST_CASE_P(
ConfigurationPolicyProviderTest,
testing::Values(TestHarness::Create));
+// Instantiate abstract test case for 3rd party policy reading tests.
+INSTANTIATE_TEST_CASE_P(
+ ConfigDir3rdPartyPolicyLoaderTest,
+ Configuration3rdPartyPolicyProviderTest,
+ testing::Values(TestHarness::Create));
+
// Some tests that exercise special functionality in ConfigDirPolicyLoader.
class ConfigDirPolicyLoaderTest : public PolicyTestBase {
protected:
@@ -200,48 +225,4 @@ TEST_F(ConfigDirPolicyLoaderTest, ReadPrefsMergePrefs) {
EXPECT_TRUE(bundle->Equals(expected_bundle));
}
-// Tests loading of policy for 3rd parties.
-TEST_F(ConfigDirPolicyLoaderTest, Load3rdParty) {
- base::DictionaryValue policy_dict;
- policy_dict.SetBoolean("bool", true);
- policy_dict.SetString("str", "string value");
- policy_dict.SetDouble("double", 123.456);
- policy_dict.SetInteger("int", 789);
-
- base::ListValue* list = new base::ListValue();
- for (int i = 0; i < 5; ++i) {
- base::DictionaryValue* dict = new base::DictionaryValue();
- dict->SetInteger("subdictindex", i);
- dict->Set("subdict", policy_dict.DeepCopy());
- list->Append(dict);
- }
- policy_dict.Set("list", list);
-
- base::DictionaryValue json_dict;
- // Merge |policy_dict|, which will become the chrome policies.
- json_dict.MergeDictionary(&policy_dict);
- json_dict.Set("3rdparty.extensions.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
- policy_dict.DeepCopy());
- json_dict.Set("3rdparty.extensions.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
- policy_dict.DeepCopy());
-
- harness_.WriteConfigFile(json_dict, "policy.json");
- ConfigDirPolicyLoader loader(harness_.test_dir(), POLICY_SCOPE_USER);
- scoped_ptr<PolicyBundle> bundle(loader.Load());
- ASSERT_TRUE(bundle.get());
- PolicyMap expected_policy;
- expected_policy.LoadFrom(&policy_dict,
- POLICY_LEVEL_MANDATORY,
- POLICY_SCOPE_USER);
- PolicyBundle expected_bundle;
- expected_bundle.Get(POLICY_DOMAIN_CHROME, "").CopyFrom(expected_policy);
- expected_bundle.Get(POLICY_DOMAIN_EXTENSIONS,
- "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
- .CopyFrom(expected_policy);
- expected_bundle.Get(POLICY_DOMAIN_EXTENSIONS,
- "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
- .CopyFrom(expected_policy);
- EXPECT_TRUE(bundle->Equals(expected_bundle));
-}
-
} // namespace policy
diff --git a/chrome/browser/policy/configuration_policy_provider_test.cc b/chrome/browser/policy/configuration_policy_provider_test.cc
index c6c9ab1..5e6d3a4 100644
--- a/chrome/browser/policy/configuration_policy_provider_test.cc
+++ b/chrome/browser/policy/configuration_policy_provider_test.cc
@@ -66,6 +66,11 @@ PolicyScope PolicyProviderTestHarness::policy_scope() const {
return scope_;
}
+void PolicyProviderTestHarness::Install3rdPartyPolicy(
+ const base::DictionaryValue* policies) {
+ FAIL();
+}
+
ConfigurationPolicyProviderTest::ConfigurationPolicyProviderTest() {}
ConfigurationPolicyProviderTest::~ConfigurationPolicyProviderTest() {}
@@ -256,4 +261,66 @@ TEST(ConfigurationPolicyProviderTest, FixDeprecatedPolicies) {
EXPECT_TRUE(provider.policies().Equals(expected_bundle));
}
+Configuration3rdPartyPolicyProviderTest::
+ Configuration3rdPartyPolicyProviderTest() {}
+
+Configuration3rdPartyPolicyProviderTest::
+ ~Configuration3rdPartyPolicyProviderTest() {}
+
+TEST_P(Configuration3rdPartyPolicyProviderTest, Load3rdParty) {
+ base::DictionaryValue policy_dict;
+ policy_dict.SetBoolean("bool", true);
+ policy_dict.SetDouble("double", 123.456);
+ policy_dict.SetInteger("int", 789);
+ policy_dict.SetString("str", "string value");
+
+ base::ListValue* list = new base::ListValue();
+ for (int i = 0; i < 2; ++i) {
+ base::DictionaryValue* dict = new base::DictionaryValue();
+ dict->SetInteger("subdictindex", i);
+ dict->Set("subdict", policy_dict.DeepCopy());
+ list->Append(dict);
+ }
+ policy_dict.Set("list", list);
+ policy_dict.Set("dict", policy_dict.DeepCopy());
+
+ // Install these policies as a Chrome policy.
+ test_harness_->InstallDictionaryPolicy(
+ test_policy_definitions::kKeyDictionary, &policy_dict);
+ // Install them as 3rd party policies too.
+ base::DictionaryValue policy_3rdparty;
+ policy_3rdparty.Set("extensions.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ policy_dict.DeepCopy());
+ policy_3rdparty.Set("extensions.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+ policy_dict.DeepCopy());
+ // Install invalid 3rd party policies that shouldn't be loaded. These also
+ // help detecting memory leaks in the code paths that detect invalid input.
+ policy_3rdparty.Set("invalid-domain.component", policy_dict.DeepCopy());
+ policy_3rdparty.Set("extensions.cccccccccccccccccccccccccccccccc",
+ base::Value::CreateStringValue("invalid-value"));
+ test_harness_->Install3rdPartyPolicy(&policy_3rdparty);
+
+ provider_->RefreshPolicies();
+ loop_.RunAllPending();
+
+ PolicyMap expected_policy;
+ expected_policy.Set(test_policy_definitions::kKeyDictionary,
+ test_harness_->policy_level(),
+ test_harness_->policy_scope(),
+ policy_dict.DeepCopy());
+ PolicyBundle expected_bundle;
+ expected_bundle.Get(POLICY_DOMAIN_CHROME, "").CopyFrom(expected_policy);
+ expected_policy.Clear();
+ expected_policy.LoadFrom(&policy_dict,
+ test_harness_->policy_level(),
+ test_harness_->policy_scope());
+ expected_bundle.Get(POLICY_DOMAIN_EXTENSIONS,
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+ .CopyFrom(expected_policy);
+ expected_bundle.Get(POLICY_DOMAIN_EXTENSIONS,
+ "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
+ .CopyFrom(expected_policy);
+ EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
+}
+
} // namespace policy
diff --git a/chrome/browser/policy/configuration_policy_provider_test.h b/chrome/browser/policy/configuration_policy_provider_test.h
index a24519c..8b330f1 100644
--- a/chrome/browser/policy/configuration_policy_provider_test.h
+++ b/chrome/browser/policy/configuration_policy_provider_test.h
@@ -97,6 +97,10 @@ class PolicyProviderTestHarness {
const std::string& policy_name,
const base::DictionaryValue* policy_value) = 0;
+ // Not every provider supports installing 3rd party policy. Those who do
+ // should override this method; the default just makes the test fail.
+ virtual void Install3rdPartyPolicy(const base::DictionaryValue* policies);
+
private:
PolicyLevel level_;
PolicyScope scope_;
@@ -133,6 +137,19 @@ class ConfigurationPolicyProviderTest
DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyProviderTest);
};
+// An extension of ConfigurationPolicyProviderTest that also tests loading of
+// 3rd party policy. Policy provider implementations that support loading of
+// 3rd party policy should also instantiate these tests.
+class Configuration3rdPartyPolicyProviderTest
+ : public ConfigurationPolicyProviderTest {
+ protected:
+ Configuration3rdPartyPolicyProviderTest();
+ virtual ~Configuration3rdPartyPolicyProviderTest();
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(Configuration3rdPartyPolicyProviderTest);
+};
+
} // namespace policy
#endif // CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_PROVIDER_TEST_H_
diff --git a/chrome/browser/policy/policy_loader_mac_unittest.cc b/chrome/browser/policy/policy_loader_mac_unittest.cc
index 4d90a3e..32006d7 100644
--- a/chrome/browser/policy/policy_loader_mac_unittest.cc
+++ b/chrome/browser/policy/policy_loader_mac_unittest.cc
@@ -220,6 +220,9 @@ INSTANTIATE_TEST_CASE_P(
ConfigurationPolicyProviderTest,
testing::Values(TestHarness::Create));
+// TODO(joaodasilva): instantiate Configuration3rdPartyPolicyProviderTest too
+// once the mac loader supports 3rd party policy. http://crbug.com/108995
+
// Special test cases for some mac preferences details.
class PolicyLoaderMacTest : public PolicyTestBase {
protected:
diff --git a/chrome/browser/policy/policy_loader_win.cc b/chrome/browser/policy/policy_loader_win.cc
index df5754e..36a44fe 100644
--- a/chrome/browser/policy/policy_loader_win.cc
+++ b/chrome/browser/policy/policy_loader_win.cc
@@ -29,16 +29,23 @@
using base::win::RegKey;
using base::win::RegistryKeyIterator;
using base::win::RegistryValueIterator;
+using namespace policy::registry_constants;
namespace policy {
-namespace {
-
-// Suffix of kRegistryMandatorySubKey where 3rd party policies are stored.
-const char k3rdPartyPolicySubKey[] = "\\3rdparty\\";
+namespace registry_constants {
+ const wchar_t kPathSep[] = L"\\";
+ const wchar_t kThirdParty[] = L"3rdparty";
+ const wchar_t kMandatory[] = L"policy";
+ const wchar_t kRecommended[] = L"recommended";
+ const wchar_t kSchema[] = L"schema";
+ const char kType[] = "type";
+ const char kProperties[] = "properties";
+ const char kAdditionalProperties[] = "additionalProperties";
+ const char kItems[] = "items";
+} // namespace registry_constants
-// Path separator for registry keys.
-const wchar_t kPathSep[] = L"\\";
+namespace {
// Map of registry hives to their corresponding policy scope, in decreasing
// order of priority.
@@ -80,7 +87,7 @@ bool LoadHighestPriorityKey(const string16& key_path,
for (size_t h = 0; h < arraysize(kHives); ++h) {
string16 path(kKeyPaths[k].path);
if (!key_path.empty())
- path += ASCIIToUTF16("\\") + key_path;
+ path += kPathSep + key_path;
key->Open(kHives[h].hive, path.c_str(), KEY_READ);
if (!key->Valid())
continue;
@@ -133,9 +140,9 @@ bool ReadRegistryInteger(RegKey* key,
// Returns the Value for a Chrome string policy named |name|, or NULL if
// it wasn't found. The caller owns the returned value.
-base::Value* ReadStringValue(const string16& name,
- PolicyLevel* level,
- PolicyScope* scope) {
+base::Value* ReadChromeStringValue(const string16& name,
+ PolicyLevel* level,
+ PolicyScope* scope) {
RegKey key;
if (!LoadHighestPriorityKey(string16(), name, &key, level, scope))
return NULL;
@@ -147,9 +154,9 @@ base::Value* ReadStringValue(const string16& name,
// Returns the Value for a Chrome string list policy named |name|,
// or NULL if it wasn't found. The caller owns the returned value.
-base::Value* ReadStringListValue(const string16& name,
- PolicyLevel* level,
- PolicyScope* scope) {
+base::Value* ReadChromeStringListValue(const string16& name,
+ PolicyLevel* level,
+ PolicyScope* scope) {
RegKey key;
if (!LoadHighestPriorityKey(name, string16(), &key, level, scope))
return NULL;
@@ -163,9 +170,9 @@ base::Value* ReadStringListValue(const string16& name,
// Returns the Value for a Chrome boolean policy named |name|,
// or NULL if it wasn't found. The caller owns the returned value.
-base::Value* ReadBooleanValue(const string16& name,
- PolicyLevel* level,
- PolicyScope* scope) {
+base::Value* ReadChromeBooleanValue(const string16& name,
+ PolicyLevel* level,
+ PolicyScope* scope) {
RegKey key;
if (!LoadHighestPriorityKey(string16(), name, &key, level, scope))
return NULL;
@@ -177,9 +184,9 @@ base::Value* ReadBooleanValue(const string16& name,
// Returns the Value for a Chrome integer policy named |name|,
// or NULL if it wasn't found. The caller owns the returned value.
-base::Value* ReadIntegerValue(const string16& name,
- PolicyLevel* level,
- PolicyScope* scope) {
+base::Value* ReadChromeIntegerValue(const string16& name,
+ PolicyLevel* level,
+ PolicyScope* scope) {
RegKey key;
if (!LoadHighestPriorityKey(string16(), name, &key, level, scope))
return NULL;
@@ -191,9 +198,9 @@ base::Value* ReadIntegerValue(const string16& name,
// Returns the Value for a Chrome dictionary policy named |name|,
// or NULL if it wasn't found. The caller owns the returned value.
-base::Value* ReadDictionaryValue(const string16& name,
- PolicyLevel* level,
- PolicyScope* scope) {
+base::Value* ReadChromeDictionaryValue(const string16& name,
+ PolicyLevel* level,
+ PolicyScope* scope) {
// Dictionaries are encoded as JSON strings on Windows.
//
// A dictionary could be stored as a subkey, with each of its entries
@@ -216,10 +223,219 @@ base::Value* ReadDictionaryValue(const string16& name,
return base::JSONReader::Read(UTF16ToUTF8(value));
}
-// Loads the dictionary at |path| in the given |hive|. Ownership is transferred
-// to the caller.
-base::DictionaryValue* ReadRegistryDictionaryValue(HKEY hive,
- const string16& path) {
+// Returns the Value type described in |schema|, or |default_type| if not found.
+base::Value::Type GetType(const base::DictionaryValue* schema,
+ base::Value::Type default_type) {
+ // JSON-schema types to base::Value::Type mapping.
+ static const struct {
+ // JSON schema type.
+ const char* schema_type;
+ // Correspondent value type.
+ base::Value::Type value_type;
+ } kSchemaToValueTypeMap[] = {
+ { "array", base::Value::TYPE_LIST },
+ { "boolean", base::Value::TYPE_BOOLEAN },
+ { "integer", base::Value::TYPE_INTEGER },
+ { "null", base::Value::TYPE_NULL },
+ { "number", base::Value::TYPE_DOUBLE },
+ { "object", base::Value::TYPE_DICTIONARY },
+ { "string", base::Value::TYPE_STRING },
+ };
+
+ if (!schema)
+ return default_type;
+ std::string type;
+ if (!schema->GetString(kType, &type))
+ return default_type;
+ for (size_t i = 0; i < arraysize(kSchemaToValueTypeMap); ++i) {
+ if (type == kSchemaToValueTypeMap[i].schema_type)
+ return kSchemaToValueTypeMap[i].value_type;
+ }
+ return default_type;
+}
+
+// Returns the default type for registry entries of |reg_type|, when there is
+// no schema defined type for a policy.
+base::Value::Type GetDefaultFor(DWORD reg_type) {
+ return reg_type == REG_DWORD ? base::Value::TYPE_INTEGER :
+ base::Value::TYPE_STRING;
+}
+
+// Returns the entry with key |name| in |dictionary| (can be NULL), or NULL.
+base::DictionaryValue* GetEntry(const base::DictionaryValue* dictionary,
+ const std::string& name) {
+ if (!dictionary)
+ return NULL;
+ base::DictionaryValue* entry = NULL;
+ dictionary->GetDictionary(name, &entry);
+ return entry;
+}
+
+// Returns the schema for property |name| given the |schema| of an object.
+// Returns the "additionalProperties" schema if no specific schema for
+// |name| is present. Returns NULL if no schema is found.
+base::DictionaryValue* GetSchemaFor(const base::DictionaryValue* schema,
+ const std::string& name) {
+ base::DictionaryValue* properties = GetEntry(schema, kProperties);
+ base::DictionaryValue* sub_schema = GetEntry(properties, name);
+ if (sub_schema)
+ return sub_schema;
+ // "additionalProperties" can be a boolean, but that case is ignored.
+ return GetEntry(schema, kAdditionalProperties);
+}
+
+// Converts string |value| to another |type|, if possible.
+base::Value* ConvertComponentStringValue(const string16& value,
+ base::Value::Type type) {
+ switch (type) {
+ case base::Value::TYPE_NULL:
+ return base::Value::CreateNullValue();
+
+ case base::Value::TYPE_BOOLEAN: {
+ int int_value;
+ if (base::StringToInt(value, &int_value))
+ return base::Value::CreateBooleanValue(int_value != 0);
+ return NULL;
+ }
+
+ case base::Value::TYPE_INTEGER: {
+ int int_value;
+ if (base::StringToInt(value, &int_value))
+ return base::Value::CreateIntegerValue(int_value);
+ return NULL;
+ }
+
+ case base::Value::TYPE_DOUBLE: {
+ double double_value;
+ if (base::StringToDouble(UTF16ToUTF8(value), &double_value))
+ return base::Value::CreateDoubleValue(double_value);
+ DLOG(WARNING) << "Failed to read policy value as double: " << value;
+ return NULL;
+ }
+
+ case base::Value::TYPE_STRING:
+ return base::Value::CreateStringValue(value);
+
+ case base::Value::TYPE_DICTIONARY:
+ case base::Value::TYPE_LIST:
+ return base::JSONReader::Read(UTF16ToUTF8(value));
+
+ case base::Value::TYPE_BINARY:
+ DLOG(WARNING) << "Cannot convert REG_SZ entry to type " << type;
+ return NULL;
+ }
+ NOTREACHED();
+ return NULL;
+}
+
+// Converts an integer |value| to another |type|, if possible.
+base::Value* ConvertComponentIntegerValue(uint32 value,
+ base::Value::Type type) {
+ switch (type) {
+ case base::Value::TYPE_BOOLEAN:
+ return base::Value::CreateBooleanValue(value != 0);
+
+ case base::Value::TYPE_INTEGER:
+ return base::Value::CreateIntegerValue(value);
+
+ case base::Value::TYPE_DOUBLE:
+ return base::Value::CreateDoubleValue(value);
+
+ case base::Value::TYPE_NULL:
+ case base::Value::TYPE_STRING:
+ case base::Value::TYPE_BINARY:
+ case base::Value::TYPE_DICTIONARY:
+ case base::Value::TYPE_LIST:
+ DLOG(WARNING) << "Cannot convert REG_DWORD entry to type " << type;
+ return NULL;
+ }
+ NOTREACHED();
+ return NULL;
+}
+
+// Reads a simple (non-Dictionary, non-Array) value from the registry |key|
+// named |name| with registry type |reg_type| as a value of type |type|.
+// Returns NULL if the value could not be loaded or converted.
+base::Value* ReadComponentSimpleValue(RegKey* key,
+ const string16& name,
+ DWORD reg_type,
+ base::Value::Type type) {
+ switch (reg_type) {
+ case REG_SZ: {
+ string16 value;
+ if (ReadRegistryString(key, name, &value))
+ return ConvertComponentStringValue(value, type);
+ break;
+ }
+
+ case REG_DWORD: {
+ uint32 value;
+ if (ReadRegistryInteger(key, name, &value))
+ return ConvertComponentIntegerValue(value, type);
+ break;
+ }
+
+ default:
+ DLOG(WARNING) << "Registry type not supported for key " << name;
+ break;
+ }
+ NOTREACHED();
+ return NULL;
+}
+
+// Forward declaration for ReadComponentListValue().
+base::DictionaryValue* ReadComponentDictionaryValue(
+ HKEY hive,
+ const string16& path,
+ const base::DictionaryValue* schema);
+
+// Loads the list at |path| in the given |hive|. |schema| is a JSON schema
+// (http://json-schema.org/) that describes the expected type of the list.
+// Ownership of the result is transferred to the caller.
+base::ListValue* ReadComponentListValue(HKEY hive,
+ const string16& path,
+ const base::DictionaryValue* schema) {
+ // The sub-elements are indexed from 1 to N. They can be represented as
+ // registry values or registry keys though; use |schema| first to try to
+ // determine the right type, and if that fails default to STRING.
+
+ RegKey key(hive, path.c_str(), KEY_READ);
+ if (!key.Valid())
+ return NULL;
+
+ // Get the schema for list items.
+ schema = GetEntry(schema, kItems);
+ base::Value::Type type = GetType(schema, base::Value::TYPE_STRING);
+ base::ListValue* list = new base::ListValue();
+ for (int i = 1; ; ++i) {
+ string16 name = base::IntToString16(i);
+ base::Value* value = NULL;
+ if (type == base::Value::TYPE_DICTIONARY) {
+ value =
+ ReadComponentDictionaryValue(hive, path + kPathSep + name, schema);
+ } else if (type == base::Value::TYPE_LIST) {
+ value = ReadComponentListValue(hive, path + kPathSep + name, schema);
+ } else {
+ DWORD reg_type;
+ key.ReadValue(name.c_str(), NULL, NULL, &reg_type);
+ value = ReadComponentSimpleValue(&key, name, reg_type, type);
+ }
+ if (!value)
+ break;
+ list->Append(value);
+ }
+ return list;
+}
+
+// Loads the dictionary at |path| in the given |hive|. |schema| is a JSON
+// schema (http://json-schema.org/) that describes the expected types for the
+// dictionary entries. When the type for a certain entry isn't described in the
+// schema, a default conversion takes place. |schema| can be NULL.
+// Ownership of the result is transferred to the caller.
+base::DictionaryValue* ReadComponentDictionaryValue(
+ HKEY hive,
+ const string16& path,
+ const base::DictionaryValue* schema) {
// A "value" in the registry is like a file in a filesystem, and a "key" is
// like a directory, that contains other "values" and "keys".
// Unfortunately it is possible to have a name both as a "value" and a "key".
@@ -228,43 +444,42 @@ base::DictionaryValue* ReadRegistryDictionaryValue(HKEY hive,
// First iterate over all the "values" in |path| and convert them; then
// recurse into each "key" in |path| and convert them as dictionaries.
- base::DictionaryValue* dict = new base::DictionaryValue();
RegKey key(hive, path.c_str(), KEY_READ);
+ if (!key.Valid())
+ return NULL;
+ base::DictionaryValue* dict = new base::DictionaryValue();
for (RegistryValueIterator it(hive, path.c_str()); it.Valid(); ++it) {
- string16 name(it.Name());
- switch (it.Type()) {
- case REG_SZ: {
- string16 value;
- if (ReadRegistryString(&key, name, &value))
- dict->SetString(UTF16ToUTF8(name), value);
- break;
- }
-
- case REG_DWORD: {
- uint32 value;
- if (ReadRegistryInteger(&key, name, &value))
- dict->SetInteger(UTF16ToUTF8(name), value);
- break;
- }
-
- default:
- // TODO(joaodasilva): use a schema to determine the correct types.
- LOG(WARNING) << "Ignoring registry value with unsupported type: "
- << path << kPathSep << name;
- }
+ string16 name16(it.Name());
+ std::string name(UTF16ToUTF8(name16));
+ const base::DictionaryValue* sub_schema = GetSchemaFor(schema, name);
+ base::Value::Type type = GetType(sub_schema, GetDefaultFor(it.Type()));
+ base::Value* value =
+ ReadComponentSimpleValue(&key, name16, it.Type(), type);
+ if (value)
+ dict->Set(name, value);
}
for (RegistryKeyIterator it(hive, path.c_str()); it.Valid(); ++it) {
string16 name16(it.Name());
std::string name(UTF16ToUTF8(name16));
if (dict->HasKey(name)) {
- LOG(WARNING) << "Ignoring registry key because a value exists with the "
- "same name: " << path << kPathSep << name;
+ DLOG(WARNING) << "Ignoring registry key because a value exists with the "
+ "same name: " << path << kPathSep << name;
continue;
}
- base::DictionaryValue* value =
- ReadRegistryDictionaryValue(hive, path + kPathSep + name16);
+
+ base::DictionaryValue* sub_schema = GetSchemaFor(schema, name);
+ base::Value::Type type = GetType(sub_schema, base::Value::TYPE_DICTIONARY);
+ base::Value* value = NULL;
+ const string16 sub_path = path + kPathSep + name16;
+ if (type == base::Value::TYPE_DICTIONARY) {
+ value = ReadComponentDictionaryValue(hive, sub_path, sub_schema);
+ } else if (type == base::Value::TYPE_LIST) {
+ value = ReadComponentListValue(hive, sub_path, sub_schema);
+ } else {
+ DLOG(WARNING) << "Can't read a simple type in registry key at " << path;
+ }
if (value)
dict->Set(name, value);
}
@@ -272,6 +487,35 @@ base::DictionaryValue* ReadRegistryDictionaryValue(HKEY hive,
return dict;
}
+// Reads a JSON schema from the given |registry_value|, at the given
+// |registry_key| in |hive|. |registry_value| must be a string (REG_SZ), and
+// is decoded as JSON data. Returns NULL on failure. Ownership is transferred
+// to the caller.
+base::DictionaryValue* ReadRegistrySchema(HKEY hive,
+ const string16& registry_key,
+ const string16& registry_value) {
+ RegKey key(hive, registry_key.c_str(), KEY_READ);
+ string16 schema;
+ if (!ReadRegistryString(&key, registry_value, &schema))
+ return NULL;
+ // A JSON schema is represented in JSON too.
+ scoped_ptr<base::Value> value(base::JSONReader::Read(UTF16ToUTF8(schema)));
+ if (!value.get())
+ return NULL;
+ base::DictionaryValue* dict = NULL;
+ if (!value->GetAsDictionary(&dict))
+ return NULL;
+ // The top-level entry must be an object, and each of its properties maps
+ // a policy name to its schema.
+ if (GetType(dict, base::Value::TYPE_DICTIONARY) !=
+ base::Value::TYPE_DICTIONARY) {
+ DLOG(WARNING) << "schema top-level type isn't \"object\"";
+ return NULL;
+ }
+ value.release();
+ return dict;
+}
+
} // namespace
PolicyLoaderWin::PolicyLoaderWin(const PolicyDefinitionList* policy_list)
@@ -323,23 +567,23 @@ void PolicyLoaderWin::LoadChromePolicy(PolicyMap* chrome_policies) {
switch (current->value_type) {
case base::Value::TYPE_STRING:
- value = ReadStringValue(name, &level, &scope);
+ value = ReadChromeStringValue(name, &level, &scope);
break;
case base::Value::TYPE_LIST:
- value = ReadStringListValue(name, &level, &scope);
+ value = ReadChromeStringListValue(name, &level, &scope);
break;
case base::Value::TYPE_BOOLEAN:
- value = ReadBooleanValue(name, &level, &scope);
+ value = ReadChromeBooleanValue(name, &level, &scope);
break;
case base::Value::TYPE_INTEGER:
- value = ReadIntegerValue(name, &level, &scope);
+ value = ReadChromeIntegerValue(name, &level, &scope);
break;
case base::Value::TYPE_DICTIONARY:
- value = ReadDictionaryValue(name, &level, &scope);
+ value = ReadChromeDictionaryValue(name, &level, &scope);
break;
default:
@@ -374,8 +618,8 @@ void PolicyLoaderWin::Load3rdPartyPolicies(PolicyBundle* bundle) {
};
// Path where policies for components are stored.
- const string16 kPathPrefix =
- kRegistryMandatorySubKey + ASCIIToUTF16(k3rdPartyPolicySubKey);
+ const string16 kPathPrefix = string16(kRegistryMandatorySubKey) + kPathSep +
+ kThirdParty + kPathSep;
for (size_t h = 0; h < arraysize(kHives); ++h) {
HKEY hkey = kHives[h].hive;
@@ -390,12 +634,16 @@ void PolicyLoaderWin::Load3rdPartyPolicies(PolicyBundle* bundle) {
string16 component(domain_iterator.Name());
string16 component_path = domain_path + kPathSep + component;
+ // Load the schema for this component's policy, if present.
+ scoped_ptr<base::DictionaryValue> schema(
+ ReadRegistrySchema(hkey, component_path, kSchema));
+
for (size_t k = 0; k < arraysize(kKeyPaths); ++k) {
string16 path =
component_path + kPathSep + ASCIIToUTF16(kKeyPaths[k].path);
scoped_ptr<base::DictionaryValue> dictionary(
- ReadRegistryDictionaryValue(hkey, path));
+ ReadComponentDictionaryValue(hkey, path, schema.get()));
if (dictionary.get()) {
PolicyMap policies;
policies.LoadFrom(
diff --git a/chrome/browser/policy/policy_loader_win.h b/chrome/browser/policy/policy_loader_win.h
index a90dd1a..94c9965 100644
--- a/chrome/browser/policy/policy_loader_win.h
+++ b/chrome/browser/policy/policy_loader_win.h
@@ -50,6 +50,32 @@ class PolicyLoaderWin : public AsyncPolicyLoader,
DISALLOW_COPY_AND_ASSIGN(PolicyLoaderWin);
};
+// Constants shared with tests.
+namespace registry_constants {
+ // Path separator for registry keys.
+ extern const wchar_t kPathSep[];
+ // Registry key within Chrome's key that contains 3rd party policy.
+ extern const wchar_t kThirdParty[];
+ // Registry key within an extension's namespace that contains mandatory
+ // policy.
+ extern const wchar_t kMandatory[];
+ // Registry key within an extension's namespace that contains recommended
+ // policy.
+ extern const wchar_t kRecommended[];
+ // Registry key within an extension's namespace that contains the policy
+ // schema.
+ extern const wchar_t kSchema[];
+ // Key in a JSON schema that indicates the expected type.
+ extern const char kType[];
+ // Key in a JSON schema that indicates the expected properties of an object.
+ extern const char kProperties[];
+ // Key in a JSON schema that indicates the default schema for object
+ // properties.
+ extern const char kAdditionalProperties[];
+ // Key in a JSON schema that indicates the expected type of list items.
+ extern const char kItems[];
+} // namespace registry_constants
+
} // namespace policy
#endif // CHROME_BROWSER_POLICY_POLICY_LOADER_WIN_H_
diff --git a/chrome/browser/policy/policy_loader_win_unittest.cc b/chrome/browser/policy/policy_loader_win_unittest.cc
index 888fa8a..9173c26 100644
--- a/chrome/browser/policy/policy_loader_win_unittest.cc
+++ b/chrome/browser/policy/policy_loader_win_unittest.cc
@@ -9,6 +9,7 @@
#include "base/json/json_writer.h"
#include "base/string16.h"
#include "base/string_number_conversions.h"
+#include "base/string_util.h"
#include "base/utf_string_conversions.h"
#include "base/win/registry.h"
#include "chrome/browser/policy/async_policy_provider.h"
@@ -19,6 +20,7 @@
#include "testing/gtest/include/gtest/gtest.h"
using base::win::RegKey;
+using namespace policy::registry_constants;
namespace policy {
@@ -30,54 +32,162 @@ const wchar_t kUnitTestMachineOverrideSubKey[] =
const wchar_t kUnitTestUserOverrideSubKey[] =
L"SOFTWARE\\Chromium Unit Tests\\HKCU Override";
-// Installs |dict| at the given |path|, in the given |hive|. Currently only
-// string, int and dictionary types are converted; other types cause a failure.
-// Returns false if there was any failure, and true if |dict| was successfully
-// written.
-// TODO(joaodasilva): generate a schema for |dict| too, so that all types can
-// be retrieved.
-bool InstallDictionary(const base::DictionaryValue& dict,
- HKEY hive,
- const string16& path) {
+// Installs |value| in the given registry |path| and |hive|, under the key
+// |name|. Returns false on errors.
+// Some of the possible Value types are stored after a conversion (e.g. doubles
+// are stored as strings), and can only be retrieved if a corresponding schema
+// is written.
+bool InstallValue(const base::Value& value,
+ HKEY hive,
+ const string16& path,
+ const string16& name) {
// KEY_ALL_ACCESS causes the ctor to create the key if it does not exist yet.
RegKey key(hive, path.c_str(), KEY_ALL_ACCESS);
- const string16 kPathSep = ASCIIToUTF16("\\");
-
- for (base::DictionaryValue::Iterator it(dict); it.HasNext(); it.Advance()) {
- string16 name(UTF8ToUTF16(it.key()));
- switch (it.value().GetType()) {
- case base::Value::TYPE_STRING: {
- string16 value;
- if (!it.value().GetAsString(&value))
- return false;
- if (key.WriteValue(name.c_str(), value.c_str()) != ERROR_SUCCESS)
+ switch (value.GetType()) {
+ case base::Value::TYPE_NULL:
+ return key.WriteValue(name.c_str(), L"") == ERROR_SUCCESS;
+
+ case base::Value::TYPE_BOOLEAN: {
+ bool bool_value;
+ if (!value.GetAsBoolean(&bool_value))
+ return false;
+ return key.WriteValue(name.c_str(), bool_value ? 1 : 0) == ERROR_SUCCESS;
+ }
+
+ case base::Value::TYPE_INTEGER: {
+ int int_value;
+ if (!value.GetAsInteger(&int_value))
+ return false;
+ return key.WriteValue(name.c_str(), int_value) == ERROR_SUCCESS;
+ }
+
+ case base::Value::TYPE_DOUBLE: {
+ double double_value;
+ if (!value.GetAsDouble(&double_value))
+ return false;
+ string16 str_value = UTF8ToUTF16(base::DoubleToString(double_value));
+ return key.WriteValue(name.c_str(), str_value.c_str()) == ERROR_SUCCESS;
+ }
+
+ case base::Value::TYPE_STRING: {
+ string16 str_value;
+ if (!value.GetAsString(&str_value))
+ return false;
+ return key.WriteValue(name.c_str(), str_value.c_str()) == ERROR_SUCCESS;
+ }
+
+ case base::Value::TYPE_DICTIONARY: {
+ const base::DictionaryValue* sub_dict = NULL;
+ if (!value.GetAsDictionary(&sub_dict))
+ return false;
+ for (base::DictionaryValue::Iterator it(*sub_dict);
+ it.HasNext(); it.Advance()) {
+ if (!InstallValue(it.value(), hive, path + kPathSep + name,
+ UTF8ToUTF16(it.key()))) {
return false;
- break;
+ }
}
+ return true;
+ }
- case base::Value::TYPE_INTEGER: {
- int value;
- if (!it.value().GetAsInteger(&value))
+ case base::Value::TYPE_LIST: {
+ const base::ListValue* list = NULL;
+ if (!value.GetAsList(&list))
+ return false;
+ for (size_t i = 0; i < list->GetSize(); ++i) {
+ base::Value* item;
+ if (!list->Get(i, &item))
return false;
- if (key.WriteValue(name.c_str(), value) != ERROR_SUCCESS)
+ if (!InstallValue(*item, hive, path + kPathSep + name,
+ base::UintToString16(i + 1))) {
return false;
- break;
+ }
}
+ return true;
+ }
- case base::Value::TYPE_DICTIONARY: {
- const base::DictionaryValue* sub_dict = NULL;
- if (!it.value().GetAsDictionary(&sub_dict))
- return false;
- if (!InstallDictionary(*sub_dict, hive, path + kPathSep + name))
- return false;
- break;
+ case base::Value::TYPE_BINARY:
+ return false;
+ }
+ NOTREACHED();
+ return false;
+}
+
+// Builds a JSON schema that represents the types contained in |value|.
+// Ownership is transferred to the caller.
+base::DictionaryValue* BuildSchema(const base::Value& value) {
+ base::DictionaryValue* schema = new base::DictionaryValue();
+ switch (value.GetType()) {
+ case base::Value::TYPE_NULL:
+ schema->SetString(kType, "null");
+ break;
+ case base::Value::TYPE_BOOLEAN:
+ schema->SetString(kType, "boolean");
+ break;
+ case base::Value::TYPE_INTEGER:
+ schema->SetString(kType, "integer");
+ break;
+ case base::Value::TYPE_DOUBLE:
+ schema->SetString(kType, "number");
+ break;
+ case base::Value::TYPE_STRING:
+ schema->SetString(kType, "string");
+ break;
+
+ case base::Value::TYPE_LIST: {
+ // Assumes every list element has the same type.
+ const base::ListValue* list = NULL;
+ if (value.GetAsList(&list) && !list->empty()) {
+ schema->SetString(kType, "array");
+ schema->Set(kItems, BuildSchema(**list->begin()));
}
+ break;
+ }
- default:
- return false;
+ case base::Value::TYPE_DICTIONARY: {
+ const base::DictionaryValue* dict = NULL;
+ if (value.GetAsDictionary(&dict)) {
+ base::DictionaryValue* properties = new base::DictionaryValue();
+ for (base::DictionaryValue::Iterator it(*dict);
+ it.HasNext(); it.Advance()) {
+ properties->Set(it.key(), BuildSchema(it.value()));
+ }
+ schema->SetString(kType, "object");
+ schema->Set(kProperties, properties);
+ }
+ break;
}
+
+ case base::Value::TYPE_BINARY:
+ break;
}
- return true;
+ return schema;
+}
+
+// Writes a JSON |schema| at the registry entry |name| at |path|
+// in the given |hive|. Returns false on failure.
+bool WriteSchema(const base::DictionaryValue& schema,
+ HKEY hive,
+ const string16& path,
+ const string16& name) {
+ std::string encoded;
+ base::JSONWriter::Write(&schema, &encoded);
+ if (encoded.empty())
+ return false;
+ string16 encoded16 = UTF8ToUTF16(encoded);
+ // KEY_ALL_ACCESS causes the ctor to create the key if it does not exist yet.
+ RegKey key(hive, path.c_str(), KEY_ALL_ACCESS);
+ return key.WriteValue(name.c_str(), encoded16.c_str()) == ERROR_SUCCESS;
+}
+
+// Builds a JSON schema for |value| and writes it at the registry entry |name|
+// at |path| in the given |hive|. Returns false on failure.
+bool InstallSchema(const base::Value& value,
+ HKEY hive,
+ const string16& path,
+ const string16& name) {
+ scoped_ptr<base::DictionaryValue> schema_dict(BuildSchema(value));
+ return WriteSchema(*schema_dict, hive, path, name);
}
// This class provides sandboxing and mocking for the parts of the Windows
@@ -130,6 +240,8 @@ class TestHarness : public PolicyProviderTestHarness {
virtual void InstallDictionaryPolicy(
const std::string& policy_name,
const base::DictionaryValue* policy_value) OVERRIDE;
+ virtual void Install3rdPartyPolicy(
+ const base::DictionaryValue* policies) OVERRIDE;
// Creates a harness instance that will install policy in HKCU or HKLM,
// respectively.
@@ -247,6 +359,30 @@ void TestHarness::InstallDictionaryPolicy(
UTF8ToUTF16(json).c_str());
}
+void TestHarness::Install3rdPartyPolicy(const base::DictionaryValue* policies) {
+ // The first level entries are domains, and the second level entries map
+ // components to their policy.
+ const string16 kPathPrefix = string16(kRegistryMandatorySubKey) + kPathSep +
+ kThirdParty + kPathSep;
+ for (base::DictionaryValue::Iterator domain(*policies);
+ domain.HasNext(); domain.Advance()) {
+ const base::DictionaryValue* components = NULL;
+ if (!domain.value().GetAsDictionary(&components)) {
+ ADD_FAILURE();
+ continue;
+ }
+ for (base::DictionaryValue::Iterator component(*components);
+ component.HasNext(); component.Advance()) {
+ const string16 path = string16(kRegistryMandatorySubKey) + kPathSep +
+ kThirdParty + kPathSep +
+ UTF8ToUTF16(domain.key()) + kPathSep +
+ UTF8ToUTF16(component.key());
+ InstallValue(component.value(), hive_, path, kMandatory);
+ EXPECT_TRUE(InstallSchema(component.value(), hive_, path, kSchema));
+ }
+ }
+}
+
// static
PolicyProviderTestHarness* TestHarness::CreateHKCU() {
return new TestHarness(HKEY_CURRENT_USER, POLICY_SCOPE_USER);
@@ -265,12 +401,24 @@ INSTANTIATE_TEST_CASE_P(
ConfigurationPolicyProviderTest,
testing::Values(TestHarness::CreateHKCU, TestHarness::CreateHKLM));
+// Instantiate abstract test case for 3rd party policy reading tests.
+INSTANTIATE_TEST_CASE_P(
+ ThirdPartyPolicyProviderWinTest,
+ Configuration3rdPartyPolicyProviderTest,
+ testing::Values(TestHarness::CreateHKCU, TestHarness::CreateHKLM));
+
// Test cases for windows policy provider specific functionality.
class PolicyLoaderWinTest : public PolicyTestBase {
protected:
PolicyLoaderWinTest() {}
virtual ~PolicyLoaderWinTest() {}
+ bool Matches(const PolicyBundle& expected) {
+ PolicyLoaderWin loader(&test_policy_definitions::kList);
+ scoped_ptr<PolicyBundle> loaded(loader.Load());
+ return loaded->Equals(expected);
+ }
+
ScopedGroupPolicyRegistrySandbox registry_sandbox_;
};
@@ -282,21 +430,16 @@ TEST_F(PolicyLoaderWinTest, HKLMOverHKCU) {
hkcu_key.WriteValue(UTF8ToUTF16(test_policy_definitions::kKeyString).c_str(),
UTF8ToUTF16("hkcu").c_str());
- PolicyLoaderWin loader(&test_policy_definitions::kList);
- scoped_ptr<PolicyBundle> bundle(loader.Load());
-
- PolicyBundle expected_bundle;
- expected_bundle.Get(POLICY_DOMAIN_CHROME, "")
+ PolicyBundle expected;
+ expected.Get(POLICY_DOMAIN_CHROME, "")
.Set(test_policy_definitions::kKeyString,
POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_MACHINE,
base::Value::CreateStringValue("hklm"));
- EXPECT_TRUE(bundle->Equals(expected_bundle));
+ EXPECT_TRUE(Matches(expected));
}
-// TODO(joaodasilva): share tests for 3rd party policy with
-// ConfigDirPolicyProvider once PolicyLoaderWin is able to load all types.
-TEST_F(PolicyLoaderWinTest, Load3rdParty) {
+TEST_F(PolicyLoaderWinTest, Load3rdPartyWithoutSchema) {
base::DictionaryValue dict;
dict.SetString("str", "string value");
dict.SetInteger("int", 123);
@@ -305,22 +448,19 @@ TEST_F(PolicyLoaderWinTest, Load3rdParty) {
dict.Set("subsubsubdict", dict.DeepCopy());
base::DictionaryValue policy_dict;
- policy_dict.Set("3rdparty.extensions.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.policy",
+ policy_dict.Set("extensions.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.policy",
dict.DeepCopy());
- policy_dict.Set("3rdparty.extensions.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.policy",
+ policy_dict.Set("extensions.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.policy",
dict.DeepCopy());
- EXPECT_TRUE(InstallDictionary(policy_dict, HKEY_LOCAL_MACHINE,
- kRegistryMandatorySubKey));
+ EXPECT_TRUE(InstallValue(policy_dict, HKEY_LOCAL_MACHINE,
+ kRegistryMandatorySubKey, kThirdParty));
PolicyBundle expected;
expected.Get(POLICY_DOMAIN_EXTENSIONS, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
.LoadFrom(&dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
expected.Get(POLICY_DOMAIN_EXTENSIONS, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
.LoadFrom(&dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
-
- PolicyLoaderWin loader(&test_policy_definitions::kList);
- scoped_ptr<PolicyBundle> loaded(loader.Load());
- EXPECT_TRUE(loaded->Equals(expected));
+ EXPECT_TRUE(Matches(expected));
}
TEST_F(PolicyLoaderWinTest, Merge3rdPartyPolicies) {
@@ -329,8 +469,6 @@ TEST_F(PolicyLoaderWinTest, Merge3rdPartyPolicies) {
const string16 kPathSuffix =
kRegistryMandatorySubKey + ASCIIToUTF16("\\3rdparty\\extensions\\merge");
- const string16 kMandatoryPath = kPathSuffix + ASCIIToUTF16("\\policy");
- const string16 kRecommendedPath = kPathSuffix + ASCIIToUTF16("\\recommended");
const char kUserMandatory[] = "user-mandatory";
const char kUserRecommended[] = "user-recommended";
@@ -339,19 +477,23 @@ TEST_F(PolicyLoaderWinTest, Merge3rdPartyPolicies) {
base::DictionaryValue policy;
policy.SetString("a", kMachineMandatory);
- EXPECT_TRUE(InstallDictionary(policy, HKEY_LOCAL_MACHINE, kMandatoryPath));
+ EXPECT_TRUE(InstallValue(policy, HKEY_LOCAL_MACHINE,
+ kPathSuffix, kMandatory));
policy.SetString("a", kUserMandatory);
policy.SetString("b", kUserMandatory);
- EXPECT_TRUE(InstallDictionary(policy, HKEY_CURRENT_USER, kMandatoryPath));
+ EXPECT_TRUE(InstallValue(policy, HKEY_CURRENT_USER,
+ kPathSuffix, kMandatory));
policy.SetString("a", kMachineRecommended);
policy.SetString("b", kMachineRecommended);
policy.SetString("c", kMachineRecommended);
- EXPECT_TRUE(InstallDictionary(policy, HKEY_LOCAL_MACHINE, kRecommendedPath));
+ EXPECT_TRUE(InstallValue(policy, HKEY_LOCAL_MACHINE,
+ kPathSuffix, kRecommended));
policy.SetString("a", kUserRecommended);
policy.SetString("b", kUserRecommended);
policy.SetString("c", kUserRecommended);
policy.SetString("d", kUserRecommended);
- EXPECT_TRUE(InstallDictionary(policy, HKEY_CURRENT_USER, kRecommendedPath));
+ EXPECT_TRUE(InstallValue(policy, HKEY_CURRENT_USER,
+ kPathSuffix, kRecommended));
PolicyBundle expected;
PolicyMap& expected_policy = expected.Get(POLICY_DOMAIN_EXTENSIONS, "merge");
@@ -363,10 +505,112 @@ TEST_F(PolicyLoaderWinTest, Merge3rdPartyPolicies) {
base::Value::CreateStringValue(kMachineRecommended));
expected_policy.Set("d", POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
base::Value::CreateStringValue(kUserRecommended));
+ EXPECT_TRUE(Matches(expected));
+}
+
+TEST_F(PolicyLoaderWinTest, LoadStringEncodedValues) {
+ // Create a dictionary with all the types that can be stored encoded in a
+ // string, to pass to InstallSchema(). Also build an equivalent dictionary
+ // with the encoded values, to pass to InstallValue().
+ base::DictionaryValue policy;
+ policy.Set("null", base::Value::CreateNullValue());
+ policy.SetBoolean("bool", true);
+ policy.SetInteger("int", -123);
+ policy.SetDouble("double", 456.78e9);
+ base::ListValue list;
+ list.Append(policy.DeepCopy());
+ list.Append(policy.DeepCopy());
+ policy.Set("list", list.DeepCopy());
+ // Encode |policy| before adding the "dict" entry.
+ std::string encoded_dict;
+ base::JSONWriter::Write(&policy, &encoded_dict);
+ ASSERT_FALSE(encoded_dict.empty());
+ policy.Set("dict", policy.DeepCopy());
+
+ std::string encoded_list;
+ base::JSONWriter::Write(&list, &encoded_list);
+ ASSERT_FALSE(encoded_list.empty());
+ base::DictionaryValue encoded_policy;
+ encoded_policy.SetString("null", "");
+ encoded_policy.SetString("bool", "1");
+ encoded_policy.SetString("int", "-123");
+ encoded_policy.SetString("double", "456.78e9");
+ encoded_policy.SetString("list", encoded_list);
+ encoded_policy.SetString("dict", encoded_dict);
+
+ const string16 kPathSuffix =
+ kRegistryMandatorySubKey + ASCIIToUTF16("\\3rdparty\\extensions\\string");
+ EXPECT_TRUE(InstallSchema(policy, HKEY_CURRENT_USER, kPathSuffix, kSchema));
+ EXPECT_TRUE(
+ InstallValue(encoded_policy, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
+
+ PolicyBundle expected;
+ expected.Get(POLICY_DOMAIN_EXTENSIONS, "string")
+ .LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+ EXPECT_TRUE(Matches(expected));
+}
+
+TEST_F(PolicyLoaderWinTest, LoadIntegerEncodedValues) {
+ base::DictionaryValue policy;
+ policy.SetBoolean("bool", true);
+ policy.SetInteger("int", 123);
+ policy.SetDouble("double", 456.0);
+
+ base::DictionaryValue encoded_policy;
+ encoded_policy.SetInteger("bool", 1);
+ encoded_policy.SetInteger("int", 123);
+ encoded_policy.SetInteger("double", 456);
+
+ const string16 kPathSuffix =
+ kRegistryMandatorySubKey + ASCIIToUTF16("\\3rdparty\\extensions\\int");
+ EXPECT_TRUE(InstallSchema(policy, HKEY_CURRENT_USER, kPathSuffix, kSchema));
+ EXPECT_TRUE(
+ InstallValue(encoded_policy, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
- PolicyLoaderWin loader(&test_policy_definitions::kList);
- scoped_ptr<PolicyBundle> loaded(loader.Load());
- EXPECT_TRUE(loaded->Equals(expected));
+ PolicyBundle expected;
+ expected.Get(POLICY_DOMAIN_EXTENSIONS, "int")
+ .LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+ EXPECT_TRUE(Matches(expected));
+}
+
+TEST_F(PolicyLoaderWinTest, DefaultPropertySchemaType) {
+ // Build a schema for an "object" with a default schema for its properties.
+ base::DictionaryValue default_schema;
+ default_schema.SetString(kType, "number");
+ base::DictionaryValue integer_schema;
+ integer_schema.SetString(kType, "integer");
+ base::DictionaryValue properties;
+ properties.Set("special-int1", integer_schema.DeepCopy());
+ properties.Set("special-int2", integer_schema.DeepCopy());
+ base::DictionaryValue schema;
+ schema.SetString(kType, "object");
+ schema.Set(kProperties, properties.DeepCopy());
+ schema.Set(kAdditionalProperties, default_schema.DeepCopy());
+
+ const string16 kPathSuffix =
+ kRegistryMandatorySubKey + ASCIIToUTF16("\\3rdparty\\extensions\\test");
+ EXPECT_TRUE(WriteSchema(schema, HKEY_CURRENT_USER, kPathSuffix, kSchema));
+
+ // Write some test values.
+ base::DictionaryValue policy;
+ // These special values have a specific schema for them.
+ policy.SetInteger("special-int1", 123);
+ policy.SetString("special-int2", "-456");
+ // Other values default to be loaded as doubles.
+ policy.SetInteger("double1", 789.0);
+ policy.SetString("double2", "123.456e7");
+ policy.SetString("invalid", "omg");
+ EXPECT_TRUE(InstallValue(policy, 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);
+ PolicyBundle expected;
+ expected.Get(POLICY_DOMAIN_EXTENSIONS, "test")
+ .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+ EXPECT_TRUE(Matches(expected));
}
} // namespace policy
generated by cgit v1.1 at 2024-10-30 05:31:14 +0000