Removed ConfigurationPolicyType and extended PolicyMap.

chrome/browser/policy/user_policy_cache_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 "chrome/browser/policy/user_policy_cache.h"
 
 #include <limits>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/values.h"
 #include "chrome/browser/policy/proto/cloud_policy.pb.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "chrome/browser/policy/proto/old_generic_format.pb.h"
 #include "content/test/test_browser_thread.h"
+#include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using testing::_;
 
 namespace em = enterprise_management;
 
 namespace policy {
 
-// Decodes a CloudPolicySettings object into two maps with mandatory and
-// recommended settings, respectively. The implementation is generated code
-// in policy/cloud_policy_generated.cc.
+// Decodes a CloudPolicySettings object into a PolicyMap.
+// The implementation is generated code in policy/cloud_policy_generated.cc.
 void DecodePolicy(const em::CloudPolicySettings& policy,
-                  PolicyMap* mandatory, PolicyMap* recommended);
+                  PolicyMap* policies);
 
 // The implementations of these methods are in cloud_policy_generated.cc.
 Value* DecodeIntegerValue(google::protobuf::int64 value);
 ListValue* DecodeStringList(const em::StringList& string_list);
 
 class MockCloudPolicyCacheBaseObserver
     : public CloudPolicyCacheBase::Observer {
  public:
   MockCloudPolicyCacheBaseObserver() {}
   virtual ~MockCloudPolicyCacheBaseObserver() {}
@@ skipping 73 matching lines @@
   }
 
   void SetReady(UserPolicyCache* cache) {
     cache->SetReady();
   }
 
   FilePath test_file() {
     return temp_dir_.path().AppendASCII("UserPolicyCacheTest");
   }
 
-  const PolicyMap& mandatory_policy(const UserPolicyCache& cache) {
-    return cache.mandatory_policy_;
-  }
-
-  const PolicyMap& recommended_policy(const UserPolicyCache& cache) {
-    return cache.recommended_policy_;
-  }
-
   MessageLoop loop_;
   MockCloudPolicyCacheBaseObserver observer_;
 
  private:
   ScopedTempDir temp_dir_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 };
 
 TEST_F(UserPolicyCacheTest, DecodePolicy) {
   em::CloudPolicySettings settings;
   settings.mutable_homepagelocation()->set_homepagelocation("chromium.org");
   settings.mutable_javascriptenabled()->set_javascriptenabled(true);
   settings.mutable_javascriptenabled()->mutable_policy_options()->set_mode(
       em::PolicyOptions::MANDATORY);
   settings.mutable_policyrefreshrate()->set_policyrefreshrate(5);
   settings.mutable_policyrefreshrate()->mutable_policy_options()->set_mode(
       em::PolicyOptions::RECOMMENDED);
   settings.mutable_showhomebutton()->set_showhomebutton(true);
   settings.mutable_showhomebutton()->mutable_policy_options()->set_mode(
       em::PolicyOptions::UNSET);
 #ifdef NDEBUG
   // Setting an invalid PolicyMode enum value triggers a DCHECK in protobuf.
   settings.mutable_homepageisnewtabpage()->set_homepageisnewtabpage(true);
   settings.mutable_homepageisnewtabpage()->mutable_policy_options()->set_mode(
       static_cast<em::PolicyOptions::PolicyMode>(-1));
 #endif
-  PolicyMap mandatory_policy;
-  PolicyMap recommended_policy;
-  DecodePolicy(settings, &mandatory_policy, &recommended_policy);
-  PolicyMap mandatory;
-  mandatory.Set(kPolicyHomepageLocation,
-                Value::CreateStringValue("chromium.org"));
-  mandatory.Set(kPolicyJavascriptEnabled, Value::CreateBooleanValue(true));
-  PolicyMap recommended;
-  recommended.Set(kPolicyPolicyRefreshRate, Value::CreateIntegerValue(5));
-  EXPECT_TRUE(mandatory.Equals(mandatory_policy));
-  EXPECT_TRUE(recommended.Equals(recommended_policy));
+  PolicyMap policy;
+  DecodePolicy(settings, &policy);
+  PolicyMap expected;
+  expected.Set(key::kHomepageLocation,
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               Value::CreateStringValue("chromium.org"));
+  expected.Set(key::kJavascriptEnabled,
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               Value::CreateBooleanValue(true));
+  expected.Set(key::kPolicyRefreshRate,
+               POLICY_LEVEL_RECOMMENDED,
+               POLICY_SCOPE_USER,
+               Value::CreateIntegerValue(5));
+  EXPECT_TRUE(policy.Equals(expected));
 }
 
 TEST_F(UserPolicyCacheTest, DecodeIntegerValue) {
   const int min = std::numeric_limits<int>::min();
   const int max = std::numeric_limits<int>::max();
   scoped_ptr<Value> value(
       DecodeIntegerValue(static_cast<google::protobuf::int64>(42)));
   ASSERT_TRUE(value.get());
   base::FundamentalValue expected_42(42);
   EXPECT_TRUE(value->Equals(&expected_42));
@@ skipping 20 matching lines @@
   scoped_ptr<ListValue> decoded(DecodeStringList(string_list));
   ListValue expected;
   expected.Append(Value::CreateStringValue("ponies"));
   expected.Append(Value::CreateStringValue("more ponies"));
   EXPECT_TRUE(decoded->Equals(&expected));
 }
 
 TEST_F(UserPolicyCacheTest, Empty) {
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   PolicyMap empty;
-  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
-  EXPECT_TRUE(empty.Equals(recommended_policy(cache)));
+  EXPECT_TRUE(empty.Equals(*cache.policy()));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(UserPolicyCacheTest, LoadNoFile) {
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.Load();
   loop_.RunAllPending();
   PolicyMap empty;
-  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
+  EXPECT_TRUE(empty.Equals(*cache.policy()));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(UserPolicyCacheTest, RejectFuture) {
   scoped_ptr<em::PolicyFetchResponse> policy_response(
       CreateHomepagePolicy("", base::Time::NowFromSystemTime() +
                                base::TimeDelta::FromMinutes(5),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy_response);
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.Load();
   loop_.RunAllPending();
   PolicyMap empty;
-  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
+  EXPECT_TRUE(empty.Equals(*cache.policy()));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(UserPolicyCacheTest, LoadWithFile) {
   scoped_ptr<em::PolicyFetchResponse> policy_response(
       CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy_response);
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.Load();
   loop_.RunAllPending();
   PolicyMap empty;
-  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
+  EXPECT_TRUE(empty.Equals(*cache.policy()));
   EXPECT_NE(base::Time(), cache.last_policy_refresh_time());
   EXPECT_GE(base::Time::Now(), cache.last_policy_refresh_time());
 }
 
 TEST_F(UserPolicyCacheTest, LoadWithData) {
   scoped_ptr<em::PolicyFetchResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy);
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.Load();
   loop_.RunAllPending();
   PolicyMap expected;
-  expected.Set(kPolicyHomepageLocation,
+  expected.Set(key::kHomepageLocation,
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
-  EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
+  EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, SetPolicy) {
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   em::PolicyFetchResponse* policy =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, policy);
   em::PolicyFetchResponse* policy2 =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, policy2);
   PolicyMap expected;
-  expected.Set(kPolicyHomepageLocation,
+  expected.Set(key::kHomepageLocation,
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
-  PolicyMap empty;
-  EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
-  EXPECT_TRUE(empty.Equals(recommended_policy(cache)));
+  EXPECT_TRUE(expected.Equals(*cache.policy()));
   policy = CreateHomepagePolicy("http://www.example.com",
                                 base::Time::NowFromSystemTime(),
                                 em::PolicyOptions::RECOMMENDED);
   SetPolicy(&cache, policy);
-  EXPECT_TRUE(expected.Equals(recommended_policy(cache)));
-  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
+  expected.Set(key::kHomepageLocation,
+               POLICY_LEVEL_RECOMMENDED,
+               POLICY_SCOPE_USER,
+               Value::CreateStringValue("http://www.example.com"));
+  EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, ResetPolicy) {
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
 
   em::PolicyFetchResponse* policy =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, policy);
   PolicyMap expected;
-  expected.Set(kPolicyHomepageLocation,
+  expected.Set(key::kHomepageLocation,
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
-  EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
+  EXPECT_TRUE(expected.Equals(*cache.policy()));
 
   em::PolicyFetchResponse* empty_policy =
       CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, empty_policy);
   PolicyMap empty;
-  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
+  EXPECT_TRUE(empty.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, PersistPolicy) {
   {
     UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
     scoped_ptr<em::PolicyFetchResponse> policy(
         CreateHomepagePolicy("http://www.example.com",
                              base::Time::NowFromSystemTime(),
                              em::PolicyOptions::MANDATORY));
     cache.SetPolicy(*policy);
   }
 
   loop_.RunAllPending();
 
   EXPECT_TRUE(file_util::PathExists(test_file()));
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.Load();
   loop_.RunAllPending();
   PolicyMap expected;
-  expected.Set(kPolicyHomepageLocation,
+  expected.Set(key::kHomepageLocation,
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
-  EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
+  EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, FreshPolicyOverride) {
   scoped_ptr<em::PolicyFetchResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy);
 
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   em::PolicyFetchResponse* updated_policy =
       CreateHomepagePolicy("http://www.chromium.org",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, updated_policy);
 
   cache.Load();
   loop_.RunAllPending();
   PolicyMap expected;
-  expected.Set(kPolicyHomepageLocation,
+  expected.Set(key::kHomepageLocation,
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.chromium.org"));
-  EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
+  EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, SetReady) {
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.AddObserver(&observer_);
   scoped_ptr<em::PolicyFetchResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   EXPECT_CALL(observer_, OnCacheUpdate(_)).Times(0);
@@ skipping 22 matching lines @@
   EXPECT_TRUE(
       settings.SerializeToString(signed_response.mutable_policy_value()));
   base::TimeDelta timestamp =
       base::Time::NowFromSystemTime() - base::Time::UnixEpoch();
   signed_response.set_timestamp(timestamp.InMilliseconds());
   EXPECT_TRUE(
       signed_response.SerializeToString(policy->mutable_policy_data()));
 
   SetPolicy(&cache, policy);
   PolicyMap expected;
-  expected.Set(kPolicyHomepageLocation,
+  expected.Set(key::kHomepageLocation,
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
-  PolicyMap empty;
-  EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
-  EXPECT_TRUE(empty.Equals(recommended_policy(cache)));
+  EXPECT_TRUE(expected.Equals(*cache.policy()));
   // If new-style policy comes in, it should override old-style policy.
   policy = CreateHomepagePolicy("http://www.example.com",
                                 base::Time::NowFromSystemTime(),
                                 em::PolicyOptions::RECOMMENDED);
+  expected.Set(key::kHomepageLocation,
+               POLICY_LEVEL_RECOMMENDED,
+               POLICY_SCOPE_USER,
+               Value::CreateStringValue("http://www.example.com"));
   SetPolicy(&cache, policy);
-  EXPECT_TRUE(expected.Equals(recommended_policy(cache)));
-  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
+  EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, CheckReadyNoWaiting) {
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   EXPECT_FALSE(cache.IsReady());
   cache.Load();
   loop_.RunAllPending();
   EXPECT_TRUE(cache.IsReady());
 }
 
@@ skipping 11 matching lines @@
   UserPolicyCache cache(test_file(), true  /* wait_for_policy_fetch */);
   EXPECT_FALSE(cache.IsReady());
   cache.SetFetchingDone();
   EXPECT_FALSE(cache.IsReady());
   cache.Load();
   loop_.RunAllPending();
   EXPECT_TRUE(cache.IsReady());
 }
 
 }  // namespace policy