Use schemas bundled in extensions to convert policies loaded on Windows.

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 "components/json_schema/json_schema_constants.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"
 
-namespace schema = json_schema_constants;
-
 using base::win::RegKey;
 
 namespace policy {
 
 namespace {
 
 // Constants for registry key names.
 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 kSchema[] = "schema";
 const wchar_t kTestPolicyKey[] = L"chrome.policy.key";
 
 // 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,
@@ skipping 64 matching lines @@
       return true;
     }
 
     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(schema::kType, "null");
-      break;
-    case base::Value::TYPE_BOOLEAN:
-      schema->SetString(schema::kType, "boolean");
-      break;
-    case base::Value::TYPE_INTEGER:
-      schema->SetString(schema::kType, "integer");
-      break;
-    case base::Value::TYPE_DOUBLE:
-      schema->SetString(schema::kType, "number");
-      break;
-    case base::Value::TYPE_STRING:
-      schema->SetString(schema::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(schema::kType, "array");
-        schema->Set(schema::kItems, BuildSchema(**list->begin()));
-      }
-      break;
-    }
-
-    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.IsAtEnd(); it.Advance()) {
-          properties->Set(it.key(), BuildSchema(it.value()));
-        }
-        schema->SetString(schema::kType, "object");
-        schema->Set(schema::kProperties, properties);
-      }
-      break;
-    }
-
-    case base::Value::TYPE_BINARY:
-      break;
-  }
-  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);
-  EXPECT_TRUE(key.Valid());
-  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
 // Registry implementing Group Policy. It prepares two temporary sandbox keys,
 // one for HKLM and one for HKCU. A test's calls to the registry are redirected
 // by Windows to these sandboxes, allowing the tests to manipulate and access
 // policy as if it were active, but without actually changing the parts of the
 // Registry that are managed by Group Policy.
 class ScopedGroupPolicyRegistrySandbox {
  public:
   ScopedGroupPolicyRegistrySandbox();
   ~ScopedGroupPolicyRegistrySandbox();
@@ skipping 274 matching lines @@
     if (!domain.value().GetAsDictionary(&components)) {
       ADD_FAILURE();
       continue;
     }
     for (base::DictionaryValue::Iterator component(*components);
          !component.IsAtEnd(); component.Advance()) {
       const string16 path = kPathPrefix +
                             UTF8ToUTF16(domain.key()) + kPathSep +
                             UTF8ToUTF16(component.key());
       InstallValue(component.value(), hive_, path, kMandatory);
-      EXPECT_TRUE(InstallSchema(component.value(), hive_, path, kSchema));
     }
   }
 }
 
 DWORD RegistryTestHarness::GetAppliedGPOList(DWORD flags,
                                              LPCTSTR machine_name,
                                              PSID sid_user,
                                              GUID* extension_guid,
                                              PGROUP_POLICY_OBJECT* gpo_list) {
   *gpo_list = NULL;
@@ skipping 82 matching lines @@
       ADD_FAILURE();
       continue;
     }
     const string16 domain_path = kPathPrefix + UTF8ToUTF16(domain.key());
     for (base::DictionaryValue::Iterator component(*components);
          !component.IsAtEnd(); component.Advance()) {
       const string16 component_path =
           domain_path + kPathSep + UTF8ToUTF16(component.key());
       AppendPolicyToPRegFile(component_path, UTF16ToUTF8(kMandatory),
                              &component.value());
-
-      scoped_ptr<base::DictionaryValue> schema_dict(
-          BuildSchema(component.value()));
-      std::string schema_json;
-      base::JSONWriter::Write(schema_dict.get(), &schema_json);
-      if (!schema_json.empty()) {
-        AppendStringToPRegFile(component_path, UTF16ToUTF8(kSchema),
-                               schema_json);
-      }
     }
   }
 }
 
 DWORD PRegTestHarness::GetAppliedGPOList(DWORD flags,
                                          LPCTSTR machine_name,
                                          PSID sid_user,
                                          GUID* extension_guid,
                                          PGROUP_POLICY_OBJECT* gpo_list) {
   *gpo_list = flags & GPO_LIST_FLAG_MACHINE ? &gpo_ : NULL;
@@ skipping 158 matching lines @@
 
   virtual void SetUp() OVERRIDE {
     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");
-
-    // Unknown components will be filtered out. Register their names with an
-    // invalid schema to avoid that.
-    ComponentMap components;
-    components["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"] = Schema();
-    components["bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"] = Schema();
-    components["int"] = Schema();
-    components["merge"] = Schema();
-    components["string"] = Schema();
-    components["test"] = Schema();
-    schema_registry_.RegisterComponents(POLICY_DOMAIN_EXTENSIONS, components);
   }
 
   // AppliedGPOListProvider:
   virtual DWORD GetAppliedGPOList(DWORD flags,
                                   LPCTSTR machine_name,
                                   PSID sid_user,
                                   GUID* extension_guid,
                                   PGROUP_POLICY_OBJECT* gpo_list) OVERRIDE {
     *gpo_list = gpo_list_;
     return gpo_list_status_;
@@ skipping 75 matching lines @@
 
   PolicyBundle expected;
   expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .Set(test_keys::kKeyString,
            POLICY_LEVEL_MANDATORY,
            POLICY_SCOPE_MACHINE,
            base::Value::CreateStringValue("hklm"), NULL);
   EXPECT_TRUE(Matches(expected));
 }
 
-TEST_F(PolicyLoaderWinTest, Load3rdPartyWithoutSchema) {
-  base::DictionaryValue dict;
-  dict.SetString("str", "string value");
-  dict.SetInteger("int", 123);
-  dict.Set("subdict", dict.DeepCopy());
-  dict.Set("subsubdict", dict.DeepCopy());
-  dict.Set("subsubsubdict", dict.DeepCopy());
-
-  base::DictionaryValue policy_dict;
-  policy_dict.Set("extensions.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.policy",
-                  dict.DeepCopy());
-  policy_dict.Set("extensions.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.policy",
-                  dict.DeepCopy());
-  EXPECT_TRUE(InstallValue(policy_dict, HKEY_LOCAL_MACHINE,
-                           kTestPolicyKey, kThirdParty));
-
-  PolicyBundle expected;
-  expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
-                               "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
-      .LoadFrom(&dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
-  expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
-                               "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
-      .LoadFrom(&dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
-  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(
+      ns,
+      "{"
+      "  \"type\": \"object\","
+      "  \"properties\": {"
+      "    \"a\": { \"type\": \"string\" },"
+      "    \"b\": { \"type\": \"string\" },"
+      "    \"c\": { \"type\": \"string\" },"
+      "    \"d\": { \"type\": \"string\" }"
+      "  }"
+      "}"));
 
   const string16 kPathSuffix =
       kTestPolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\merge");
 
   const char kUserMandatory[] = "user-mandatory";
   const char kUserRecommended[] = "user-recommended";
   const char kMachineMandatory[] = "machine-mandatory";
   const char kMachineRecommended[] = "machine-recommended";
 
   base::DictionaryValue policy;
@@ skipping 10 matching lines @@
   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(InstallValue(policy, HKEY_CURRENT_USER,
                            kPathSuffix, kRecommended));
 
   PolicyBundle expected;
-  PolicyMap& expected_policy =
-      expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "merge"));
+  PolicyMap& expected_policy = expected.Get(ns);
   expected_policy.Set("a", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       base::Value::CreateStringValue(kMachineMandatory), NULL);
   expected_policy.Set("b", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                       base::Value::CreateStringValue(kUserMandatory), NULL);
   expected_policy.Set("c", POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
                       base::Value::CreateStringValue(kMachineRecommended),
                       NULL);
   expected_policy.Set("d", POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
                       base::Value::CreateStringValue(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, to pass to InstallSchema(). Also build an equivalent dictionary
-  // with the encoded values, to pass to InstallValue().
+  // string.
+  const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "string");
+  ASSERT_TRUE(RegisterSchema(
+      ns,
+      "{"
+      "  \"type\": \"object\","
+      "  \"id\": \"MainType\","
+      "  \"properties\": {"
+      "    \"null\": { \"type\": \"null\" },"
+      "    \"bool\": { \"type\": \"boolean\" },"
+      "    \"int\": { \"type\": \"integer\" },"
+      "    \"double\": { \"type\": \"number\" },"
+      "    \"list\": {"
+      "      \"type\": \"array\","
+      "      \"items\": { \"$ref\": \"MainType\" }"
+      "    },"
+      "    \"dict\": { \"$ref\": \"MainType\" }"
+      "  }"
+      "}"));
+
   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 =
       kTestPolicyKey + 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(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "string"))
-      .LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+  expected.Get(ns).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);
+  const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "int");
+  ASSERT_TRUE(RegisterSchema(
+      ns,
+      "{"
+      "  \"type\": \"object\","
+      "  \"properties\": {"
+      "    \"bool\": { \"type\": \"boolean\" },"
+      "    \"int\": { \"type\": \"integer\" },"
+      "    \"double\": { \"type\": \"number\" }"
+      "  }"
+      "}"));
 
   base::DictionaryValue encoded_policy;
   encoded_policy.SetInteger("bool", 1);
   encoded_policy.SetInteger("int", 123);
   encoded_policy.SetInteger("double", 456);
 
   const string16 kPathSuffix =
       kTestPolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\int");
-  EXPECT_TRUE(InstallSchema(policy, HKEY_CURRENT_USER, kPathSuffix, kSchema));
   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(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "int"))
-      .LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+  expected.Get(ns).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(schema::kType, "number");
-  base::DictionaryValue integer_schema;
-  integer_schema.SetString(schema::kType, "integer");
-  base::DictionaryValue properties;
-  properties.Set("special-int1", integer_schema.DeepCopy());
-  properties.Set("special-int2", integer_schema.DeepCopy());
-  base::DictionaryValue schema;
-  schema.SetString(schema::kType, "object");
-  schema.Set(schema::kProperties, properties.DeepCopy());
-  schema.Set(schema::kAdditionalProperties, default_schema.DeepCopy());
-
-  const string16 kPathSuffix =
-      kTestPolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\test");
-  EXPECT_TRUE(WriteSchema(schema, HKEY_CURRENT_USER, kPathSuffix, kSchema));
+  // 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,
+      "{"
+      "  \"type\": \"object\","
+      "  \"properties\": {"
+      "    \"policy\": {"
+      "      \"type\": \"object\","
+      "      \"properties\": {"
+      "        \"special-int1\": { \"type\": \"integer\" },"
+      "        \"special-int2\": { \"type\": \"integer\" }"
+      "      },"
+      "      \"additionalProperties\": { \"type\": \"number\" }"
+      "    }"
+      "  }"
+      "}"));
 
   // 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 all_policies;
+  all_policies.Set("policy", policy.DeepCopy());
+
+  const string16 kPathSuffix =
+      kTestPolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\test");
+  EXPECT_TRUE(
+      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);
-  expected_policy.Set("invalid", base::Value::CreateNullValue());
+  base::DictionaryValue expected_policies;
+  expected_policies.Set("policy", expected_policy.DeepCopy());
   PolicyBundle expected;
-  expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "test"))
-      .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+  expected.Get(ns).LoadFrom(
+      &expected_policies, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, AppliedPolicyNotPresent) {
   InstallRegistrySentinel();
   gpo_list_ = NULL;
   gpo_list_status_ = ERROR_SUCCESS;
 
   PolicyBundle empty;
   EXPECT_TRUE(Matches(empty));
@@ skipping 100 matching lines @@
 }
 
 TEST_F(PolicyLoaderWinTest, LoadExtensionPolicyAlternativeSpelling) {
   base::FilePath gpo_dir(
       test_data_dir_.AppendASCII("extension_alternative_spelling"));
   GROUP_POLICY_OBJECT gpo;
   InitGPO(&gpo, 0, gpo_dir, NULL, NULL);
   gpo_list_ = &gpo;
   gpo_list_status_ = ERROR_SUCCESS;
 
+  const char kTestSchema[] =
+      "{"
+      "  \"type\": \"object\","
+      "  \"properties\": {"
+      "    \"policy 1\": { \"type\": \"integer\" },"
+      "    \"policy 2\": { \"type\": \"integer\" }"
+      "  }"
+      "}";
+  const PolicyNamespace ns_a(
+      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(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
-                               "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
-      .LoadFrom(&expected_a, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
+  expected.Get(ns_a).LoadFrom(
+      &expected_a, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
   base::DictionaryValue expected_b;
   expected_b.SetInteger("policy 1", 2);
-  expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
-                               "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
-      .LoadFrom(&expected_b, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
+  expected.Get(ns_b).LoadFrom(
+      &expected_b, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
   EXPECT_TRUE(Matches(expected));
 }
 
+TEST_F(PolicyLoaderWinTest, LBSSupport) {
+  const PolicyNamespace ns(
+      POLICY_DOMAIN_EXTENSIONS, "heildphpnddilhkemkielfhnkaagiabh");
+  schema_registry_.RegisterComponent(ns, Schema());
+
+  const char kIncompleteSchema[] =
+      "{"
+       "  \"type\": \"object\","
+       "  \"properties\": {"
+       "    \"url_list\": { \"type\": \"array\" },"
+       "    \"url_greylist\": { \"type\": \"array\" }"
+       "  }"
+      "}";
+
+  const string16 kPathSuffix =
+      kTestPolicyKey + ASCIIToUTF16("\\3rdparty\\extensions");
+
+  base::ListValue list;
+  list.AppendString("youtube.com");
+  base::DictionaryValue policy;
+  policy.Set("url_list", list.DeepCopy());
+  policy.SetString("alternative_browser_path", "c:\\legacy\\browser.exe");
+  base::DictionaryValue root;
+  root.Set(UTF16ToUTF8(kMandatory), policy.DeepCopy());
+  root.SetString(kSchema, kIncompleteSchema);
+  EXPECT_TRUE(InstallValue(root, HKEY_LOCAL_MACHINE,
+                           kPathSuffix, ASCIIToUTF16(ns.component_id)));
+
+  PolicyBundle expected;
+  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