Use a schema to decode 3rd party policy on windows, when present.

chrome/browser/policy/config_dir_policy_loader_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 "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
@@ skipping 27 matching lines @@
   virtual void InstallIntegerPolicy(const std::string& policy_name,
                                     int policy_value) OVERRIDE;
   virtual void InstallBooleanPolicy(const std::string& policy_name,
                                     bool policy_value) OVERRIDE;
   virtual void InstallStringListPolicy(
       const std::string& policy_name,
       const base::ListValue* policy_value) OVERRIDE;
   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(); }
 
   // JSON-encode a dictionary and write it to a file.
   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() {}
 
 void TestHarness::SetUp() {
   ASSERT_TRUE(test_dir_.CreateUniqueTempDir());
 }
 
 ConfigurationPolicyProvider* TestHarness::CreateProvider(
     const PolicyDefinitionList* policy_definition_list) {
   scoped_ptr<AsyncPolicyLoader> loader(
       new ConfigDirPolicyLoader(test_dir(), POLICY_SCOPE_MACHINE));
   return new AsyncPolicyProvider(loader.Pass());
 }
 
 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(
     const std::string& policy_name,
     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,
                                   const std::string& file_name) {
   std::string data;
   JSONStringValueSerializer serializer(&data);
   serializer.Serialize(dict);
   const FilePath mandatory_dir(test_dir().Append(kMandatoryPath));
   ASSERT_TRUE(file_util::CreateDirectory(mandatory_dir));
   const FilePath file_path(mandatory_dir.AppendASCII(file_name));
   ASSERT_EQ((int) data.size(),
             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();
 }
 
 }  // namespace
 
 // Instantiate abstract test case for basic policy reading tests.
 INSTANTIATE_TEST_CASE_P(
     ConfigDirPolicyLoaderTest,
     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:
   void SetUp() OVERRIDE {
     PolicyTestBase::SetUp();
     harness_.SetUp();
   }
 
   TestHarness harness_;
 };
@@ skipping 38 matching lines @@
 
   ConfigDirPolicyLoader loader(harness_.test_dir(), POLICY_SCOPE_USER);
   scoped_ptr<PolicyBundle> bundle(loader.Load());
   ASSERT_TRUE(bundle.get());
   PolicyBundle expected_bundle;
   expected_bundle.Get(POLICY_DOMAIN_CHROME, "")
       .LoadFrom(&test_dict_foo, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
   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