Added RefreshPolicies to PolicyService.

chrome/browser/policy/configuration_policy_pref_store_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 <string>
 
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/policy/configuration_policy_handler.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/policy_service_impl.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_store_observer_mock.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Mock;
+using testing::Return;
 using testing::_;
 
 namespace policy {
 
 // Holds a set of test parameters, consisting of pref name and policy name.
 class PolicyAndPref {
  public:
   PolicyAndPref(const char* policy_name, const char* pref_name)
       : policy_name_(policy_name),
         pref_name_(pref_name) {}
 
   const char* policy_name() const { return policy_name_; }
   const char* pref_name() const { return pref_name_; }
 
  private:
   const char* policy_name_;
   const char* pref_name_;
 };
 
 class ConfigurationPolicyPrefStoreTest : public testing::Test {
  protected:
   ConfigurationPolicyPrefStoreTest() {
+    EXPECT_CALL(provider_, ProvideInternal(_))
+        .WillRepeatedly(CopyPolicyMap(&policy_));
+    EXPECT_CALL(provider_, IsInitializationComplete())
+        .WillRepeatedly(Return(true));
+    ResetServiceAndStore();
+  }
+
+  void ResetServiceAndStore() {
+    store_ = NULL;
     PolicyServiceImpl::Providers providers;
     providers.push_back(&provider_);
     policy_service_.reset(new PolicyServiceImpl(providers));
     store_ = new ConfigurationPolicyPrefStore(policy_service_.get(),
                                               POLICY_LEVEL_MANDATORY);
   }
 
+  PolicyMap policy_;
   MockConfigurationPolicyProvider provider_;
   scoped_ptr<PolicyServiceImpl> policy_service_;
   scoped_refptr<ConfigurationPolicyPrefStore> store_;
 };
 
 // Test cases for list-valued policy settings.
 class ConfigurationPolicyPrefStoreListTest
     : public ConfigurationPolicyPrefStoreTest,
       public testing::WithParamInterface<PolicyAndPref> {};
 
 TEST_P(ConfigurationPolicyPrefStoreListTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreListTest, SetValue) {
   base::ListValue* in_value = new base::ListValue();
   in_value->Append(base::Value::CreateStringValue("test1"));
   in_value->Append(base::Value::CreateStringValue("test2,"));
-  provider_.AddMandatoryPolicy(GetParam().policy_name(), in_value);
-  provider_.RefreshPolicies();
+  policy_.Set(GetParam().policy_name(), POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, in_value);
+  provider_.NotifyPolicyUpdated();
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   ASSERT_TRUE(value);
   EXPECT_TRUE(in_value->Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreListTestInstance,
     ConfigurationPolicyPrefStoreListTest,
@@ skipping 23 matching lines @@
 class ConfigurationPolicyPrefStoreStringTest
     : public ConfigurationPolicyPrefStoreTest,
       public testing::WithParamInterface<PolicyAndPref> {};
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) {
-  provider_.AddMandatoryPolicy(GetParam().policy_name(),
-                               base::Value::CreateStringValue(
-                                   "http://chromium.org"));
-  provider_.RefreshPolicies();
+  policy_.Set(GetParam().policy_name(), POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER,
+              base::Value::CreateStringValue("http://chromium.org"));
+  provider_.NotifyPolicyUpdated();
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   ASSERT_TRUE(value);
   EXPECT_TRUE(base::StringValue("http://chromium.org").Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreStringTestInstance,
     ConfigurationPolicyPrefStoreStringTest,
@@ skipping 25 matching lines @@
 class ConfigurationPolicyPrefStoreBooleanTest
     : public ConfigurationPolicyPrefStoreTest,
       public testing::WithParamInterface<PolicyAndPref> {};
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, SetValue) {
-  provider_.AddMandatoryPolicy(GetParam().policy_name(),
-                               base::Value::CreateBooleanValue(false));
-  provider_.RefreshPolicies();
+  policy_.Set(GetParam().policy_name(), POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
+  provider_.NotifyPolicyUpdated();
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   ASSERT_TRUE(value);
   bool boolean_value = true;
   bool result = value->GetAsBoolean(&boolean_value);
   ASSERT_TRUE(result);
   EXPECT_FALSE(boolean_value);
 
-  provider_.AddMandatoryPolicy(GetParam().policy_name(),
-                               base::Value::CreateBooleanValue(true));
-  provider_.RefreshPolicies();
+  policy_.Set(GetParam().policy_name(), POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
+  provider_.NotifyPolicyUpdated();
   value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   boolean_value = false;
   result = value->GetAsBoolean(&boolean_value);
   ASSERT_TRUE(result);
   EXPECT_TRUE(boolean_value);
 }
 
 INSTANTIATE_TEST_CASE_P(
@@ skipping 98 matching lines @@
 class ConfigurationPolicyPrefStoreIntegerTest
     : public ConfigurationPolicyPrefStoreTest,
       public testing::WithParamInterface<PolicyAndPref> {};
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, SetValue) {
-  provider_.AddMandatoryPolicy(GetParam().policy_name(),
-                               base::Value::CreateIntegerValue(2));
-  provider_.RefreshPolicies();
+  policy_.Set(GetParam().policy_name(), POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateIntegerValue(2));
+  provider_.NotifyPolicyUpdated();
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   EXPECT_TRUE(base::FundamentalValue(2).Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreIntegerTestInstance,
     ConfigurationPolicyPrefStoreIntegerTest,
     testing::Values(
@@ skipping 55 matching lines @@
       ASSERT_TRUE(dict.GetBypassList(&s));
       EXPECT_EQ(expected_proxy_bypass_list, s);
     }
     ProxyPrefs::ProxyMode mode;
     ASSERT_TRUE(dict.GetMode(&mode));
     EXPECT_EQ(expected_proxy_mode, mode);
   }
 };
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyBypassList,
-      base::Value::CreateStringValue("http://chromium.org/override"));
-  provider_.AddMandatoryPolicy(key::kProxyServer,
-                               base::Value::CreateStringValue("chromium.org"));
-  provider_.AddMandatoryPolicy(
-      key::kProxyServerMode,
+  policy_.Set(key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue("http://chromium.org/override"));
+  policy_.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue("chromium.org"));
+  policy_.Set(
+      key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       base::Value::CreateIntegerValue(
           ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE));
-  provider_.RefreshPolicies();
+  provider_.NotifyPolicyUpdated();
 
   VerifyProxyPrefs(
       "chromium.org", "", "http://chromium.org/override",
       ProxyPrefs::MODE_FIXED_SERVERS);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsReversedApplyOrder) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyServerMode,
+  policy_.Set(
+      key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       base::Value::CreateIntegerValue(
           ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE));
-  provider_.AddMandatoryPolicy(
-      key::kProxyBypassList,
-      base::Value::CreateStringValue("http://chromium.org/override"));
-  provider_.AddMandatoryPolicy(
-      key::kProxyServer,
-      base::Value::CreateStringValue("chromium.org"));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue("http://chromium.org/override"));
+  policy_.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue("chromium.org"));
+  provider_.NotifyPolicyUpdated();
 
   VerifyProxyPrefs(
       "chromium.org", "", "http://chromium.org/override",
       ProxyPrefs::MODE_FIXED_SERVERS);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsInvalid) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyServerMode,
+  policy_.Set(
+      key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       base::Value::CreateIntegerValue(
           ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE));
-  provider_.RefreshPolicies();
+  provider_.NotifyPolicyUpdated();
 
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_NO_VALUE, store_->GetValue(prefs::kProxy, &value));
 }
 
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyServerMode) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyServerMode,
-      base::Value::CreateIntegerValue(ProxyPolicyHandler::PROXY_SERVER_MODE));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateIntegerValue(
+                  ProxyPolicyHandler::PROXY_SERVER_MODE));
+  provider_.NotifyPolicyUpdated();
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_DIRECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyModeName) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyMode,
-      base::Value::CreateStringValue(ProxyPrefs::kDirectProxyModeName));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue(ProxyPrefs::kDirectProxyModeName));
+  provider_.NotifyPolicyUpdated();
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_DIRECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectProxyServerMode) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyServerMode,
+  policy_.Set(
+      key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       base::Value::CreateIntegerValue(
           ProxyPolicyHandler::PROXY_AUTO_DETECT_PROXY_SERVER_MODE));
-  provider_.RefreshPolicies();
+  provider_.NotifyPolicyUpdated();
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectProxyModeName) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyMode,
-      base::Value::CreateStringValue(ProxyPrefs::kAutoDetectProxyModeName));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue(
+                  ProxyPrefs::kAutoDetectProxyModeName));
+  provider_.NotifyPolicyUpdated();
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyMode) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyPacUrl,
-      base::Value::CreateStringValue("http://short.org/proxy.pac"));
-  provider_.AddMandatoryPolicy(
-      key::kProxyMode,
-      base::Value::CreateStringValue(ProxyPrefs::kPacScriptProxyModeName));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue("http://short.org/proxy.pac"));
+  policy_.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue(
+                  ProxyPrefs::kPacScriptProxyModeName));
+  provider_.NotifyPolicyUpdated();
   VerifyProxyPrefs("", "http://short.org/proxy.pac", "",
                    ProxyPrefs::MODE_PAC_SCRIPT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyModeInvalid) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyMode,
-      base::Value::CreateStringValue(ProxyPrefs::kPacScriptProxyModeName));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue(
+                  ProxyPrefs::kPacScriptProxyModeName));
+  provider_.NotifyPolicyUpdated();
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_NO_VALUE, store_->GetValue(prefs::kProxy, &value));
 }
 
 // Regression test for http://crbug.com/78016, CPanel returns empty strings
 // for unset properties.
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyModeBug78016) {
-  provider_.AddMandatoryPolicy(key::kProxyServer,
-                               base::Value::CreateStringValue(""));
-  provider_.AddMandatoryPolicy(
-      key::kProxyPacUrl,
-      base::Value::CreateStringValue("http://short.org/proxy.pac"));
-  provider_.AddMandatoryPolicy(
-      key::kProxyMode,
-      base::Value::CreateStringValue(ProxyPrefs::kPacScriptProxyModeName));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue(""));
+  policy_.Set(key::kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue("http://short.org/proxy.pac"));
+  policy_.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue(
+                  ProxyPrefs::kPacScriptProxyModeName));
+  provider_.NotifyPolicyUpdated();
   VerifyProxyPrefs("", "http://short.org/proxy.pac", "",
                    ProxyPrefs::MODE_PAC_SCRIPT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemProxyServerMode) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyServerMode,
+  policy_.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       base::Value::CreateIntegerValue(
           ProxyPolicyHandler::PROXY_USE_SYSTEM_PROXY_SERVER_MODE));
-  provider_.RefreshPolicies();
+  provider_.NotifyPolicyUpdated();
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_SYSTEM);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemProxyMode) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyMode,
-      base::Value::CreateStringValue(ProxyPrefs::kSystemProxyModeName));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue(ProxyPrefs::kSystemProxyModeName));
+  provider_.NotifyPolicyUpdated();
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_SYSTEM);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest,
        ProxyModeOverridesProxyServerMode) {
-  provider_.AddMandatoryPolicy(
-      key::kProxyServerMode,
-      base::Value::CreateIntegerValue(ProxyPolicyHandler::PROXY_SERVER_MODE));
-  provider_.AddMandatoryPolicy(
-      key::kProxyMode,
-      base::Value::CreateStringValue(ProxyPrefs::kAutoDetectProxyModeName));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateIntegerValue(
+                  ProxyPolicyHandler::PROXY_SERVER_MODE));
+  policy_.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue(
+                  ProxyPrefs::kAutoDetectProxyModeName));
+  provider_.NotifyPolicyUpdated();
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ProxyInvalid) {
   // No mode expects all three parameters being set.
-  provider_.AddMandatoryPolicy(
-      key::kProxyPacUrl,
-      base::Value::CreateStringValue("http://short.org/proxy.pac"));
-  provider_.AddMandatoryPolicy(
-      key::kProxyBypassList,
-      base::Value::CreateStringValue("http://chromium.org/override"));
-  provider_.AddMandatoryPolicy(
-      key::kProxyServer,
-      base::Value::CreateStringValue("chromium.org"));
+  policy_.Set(key::kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue("http://short.org/proxy.pac"));
+  policy_.Set(key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue("http://chromium.org/override"));
+  policy_.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue("chromium.org"));
   for (int i = 0; i < ProxyPolicyHandler::MODE_COUNT; ++i) {
-    provider_.AddMandatoryPolicy(key::kProxyServerMode,
-                                 base::Value::CreateIntegerValue(i));
-    provider_.RefreshPolicies();
+    policy_.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY,
+                POLICY_SCOPE_USER, base::Value::CreateIntegerValue(i));
+    provider_.NotifyPolicyUpdated();
     const base::Value* value = NULL;
     EXPECT_EQ(PrefStore::READ_NO_VALUE,
               store_->GetValue(prefs::kProxy, &value));
   }
 }
 
 class ConfigurationPolicyPrefStoreDefaultSearchTest
     : public ConfigurationPolicyPrefStoreTest {};
 
 // Checks that if the policy for default search is valid, i.e. there's a
 // search URL, that all the elements have been given proper defaults.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MinimallyDefined) {
   const char* const search_url = "http://test.com/search?t={searchTerms}";
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderEnabled,
-                               base::Value::CreateBooleanValue(true));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderSearchURL,
-                               base::Value::CreateStringValue(search_url));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
+  policy_.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(search_url));
+  provider_.NotifyPolicyUpdated();
 
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
   EXPECT_TRUE(base::StringValue(search_url).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderName, &value));
   EXPECT_TRUE(base::StringValue("test.com").Equals(value));
 
@@ skipping 22 matching lines @@
 // read properly.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
   const char* const search_url = "http://test.com/search?t={searchTerms}";
   const char* const suggest_url = "http://test.com/sugg?={searchTerms}";
   const char* const icon_url = "http://test.com/icon.jpg";
   const char* const name = "MyName";
   const char* const keyword = "MyKeyword";
   base::ListValue* encodings = new base::ListValue();
   encodings->Append(base::Value::CreateStringValue("UTF-16"));
   encodings->Append(base::Value::CreateStringValue("UTF-8"));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderEnabled,
-                               base::Value::CreateBooleanValue(true));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderSearchURL,
-                               base::Value::CreateStringValue(search_url));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderName,
-                               base::Value::CreateStringValue(name));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderKeyword,
-                               base::Value::CreateStringValue(keyword));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderSuggestURL,
-                               base::Value::CreateStringValue(suggest_url));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderIconURL,
-                               base::Value::CreateStringValue(icon_url));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderEncodings, encodings);
-  provider_.RefreshPolicies();
+  policy_.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
+  policy_.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(search_url));
+  policy_.Set(key::kDefaultSearchProviderName, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(name));
+  policy_.Set(key::kDefaultSearchProviderKeyword, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(keyword));
+  policy_.Set(key::kDefaultSearchProviderSuggestURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(suggest_url));
+  policy_.Set(key::kDefaultSearchProviderIconURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(icon_url));
+  policy_.Set(key::kDefaultSearchProviderEncodings, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, encodings);
+  provider_.NotifyPolicyUpdated();
 
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
   EXPECT_TRUE(base::StringValue(search_url).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderName, &value));
   EXPECT_TRUE(base::StringValue(name).Equals(value));
 
@@ skipping 17 matching lines @@
 // Checks that if the default search policy is missing, that no elements of the
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MissingUrl) {
   const char* const suggest_url = "http://test.com/sugg?t={searchTerms}";
   const char* const icon_url = "http://test.com/icon.jpg";
   const char* const name = "MyName";
   const char* const keyword = "MyKeyword";
   base::ListValue* encodings = new base::ListValue();
   encodings->Append(base::Value::CreateStringValue("UTF-16"));
   encodings->Append(base::Value::CreateStringValue("UTF-8"));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderEnabled,
-                               base::Value::CreateBooleanValue(true));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderName,
-                               base::Value::CreateStringValue(name));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderKeyword,
-                               base::Value::CreateStringValue(keyword));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderSuggestURL,
-                               base::Value::CreateStringValue(suggest_url));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderIconURL,
-                               base::Value::CreateStringValue(icon_url));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderEncodings, encodings);
-  provider_.RefreshPolicies();
+  policy_.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
+  policy_.Set(key::kDefaultSearchProviderName, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(name));
+  policy_.Set(key::kDefaultSearchProviderKeyword, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(keyword));
+  policy_.Set(key::kDefaultSearchProviderSuggestURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(suggest_url));
+  policy_.Set(key::kDefaultSearchProviderIconURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(icon_url));
+  policy_.Set(key::kDefaultSearchProviderEncodings, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, encodings);
+  provider_.NotifyPolicyUpdated();
 
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
 }
 
 // Checks that if the default search policy is invalid, that no elements of the
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Invalid) {
   const char* const bad_search_url = "http://test.com/noSearchTerms";
   const char* const suggest_url = "http://test.com/sugg?t={searchTerms}";
   const char* const icon_url = "http://test.com/icon.jpg";
   const char* const name = "MyName";
   const char* const keyword = "MyKeyword";
   base::ListValue* encodings = new base::ListValue();
   encodings->Append(base::Value::CreateStringValue("UTF-16"));
   encodings->Append(base::Value::CreateStringValue("UTF-8"));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderEnabled,
-                               base::Value::CreateBooleanValue(true));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderSearchURL,
-                               base::Value::CreateStringValue(bad_search_url));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderName,
-                               base::Value::CreateStringValue(name));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderKeyword,
-                               base::Value::CreateStringValue(keyword));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderSuggestURL,
-                               base::Value::CreateStringValue(suggest_url));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderIconURL,
-                               base::Value::CreateStringValue(icon_url));
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderEncodings, encodings);
-  provider_.RefreshPolicies();
+  policy_.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
+  policy_.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER,
+              base::Value::CreateStringValue(bad_search_url));
+  policy_.Set(key::kDefaultSearchProviderName, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(name));
+  policy_.Set(key::kDefaultSearchProviderKeyword, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(keyword));
+  policy_.Set(key::kDefaultSearchProviderSuggestURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(suggest_url));
+  policy_.Set(key::kDefaultSearchProviderIconURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(icon_url));
+  policy_.Set(key::kDefaultSearchProviderEncodings, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, encodings);
+  provider_.NotifyPolicyUpdated();
 
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
 }
 
 // Checks that if the default search policy is invalid, that no elements of the
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Disabled) {
-  provider_.AddMandatoryPolicy(key::kDefaultSearchProviderEnabled,
-                               base::Value::CreateBooleanValue(false));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
+  provider_.NotifyPolicyUpdated();
 
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderEnabled, &value));
   base::FundamentalValue expected_enabled(false);
   EXPECT_TRUE(base::Value::Equals(&expected_enabled, value));
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
   base::StringValue expected_search_url("");
   EXPECT_TRUE(base::Value::Equals(&expected_search_url, value));
 }
 
 // Tests Incognito mode availability preference setting.
 class ConfigurationPolicyPrefStoreIncognitoModeTest
     : public ConfigurationPolicyPrefStoreTest {
  protected:
   static const int kIncognitoModeAvailabilityNotSet = -1;
 
   enum ObsoleteIncognitoEnabledValue {
     INCOGNITO_ENABLED_UNKNOWN,
     INCOGNITO_ENABLED_TRUE,
     INCOGNITO_ENABLED_FALSE
   };
 
   void SetPolicies(ObsoleteIncognitoEnabledValue incognito_enabled,
                    int availability) {
     if (incognito_enabled != INCOGNITO_ENABLED_UNKNOWN) {
-      provider_.AddMandatoryPolicy(
-          key::kIncognitoEnabled,
-          base::Value::CreateBooleanValue(
-              incognito_enabled == INCOGNITO_ENABLED_TRUE));
+      policy_.Set(key::kIncognitoEnabled, POLICY_LEVEL_MANDATORY,
+                  POLICY_SCOPE_USER,
+                  base::Value::CreateBooleanValue(
+                      incognito_enabled == INCOGNITO_ENABLED_TRUE));
     }
     if (availability >= 0) {
-      provider_.AddMandatoryPolicy(
-          key::kIncognitoModeAvailability,
-          base::Value::CreateIntegerValue(availability));
+      policy_.Set(key::kIncognitoModeAvailability, POLICY_LEVEL_MANDATORY,
+                  POLICY_SCOPE_USER,
+                  base::Value::CreateIntegerValue(availability));
     }
-    provider_.RefreshPolicies();
+    provider_.NotifyPolicyUpdated();
   }
 
   void VerifyValues(IncognitoModePrefs::Availability availability) {
     const base::Value* value = NULL;
     EXPECT_EQ(PrefStore::READ_OK,
               store_->GetValue(prefs::kIncognitoModeAvailability, &value));
     EXPECT_TRUE(base::FundamentalValue(availability).Equals(value));
   }
 };
 
@@ skipping 56 matching lines @@
 // Test cases for the Sync policy setting.
 class ConfigurationPolicyPrefStoreSyncTest
     : public ConfigurationPolicyPrefStoreTest {};
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Default) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
-  provider_.AddMandatoryPolicy(key::kSyncDisabled,
-                               base::Value::CreateBooleanValue(false));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kSyncDisabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateBooleanValue(false));
+  provider_.NotifyPolicyUpdated();
   // Enabling Sync should not set the pref.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Disabled) {
-  provider_.AddMandatoryPolicy(key::kSyncDisabled,
-                               base::Value::CreateBooleanValue(true));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kSyncDisabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateBooleanValue(true));
+  provider_.NotifyPolicyUpdated();
   // Sync should be flagged as managed.
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(prefs::kSyncManaged, &value));
   ASSERT_TRUE(value);
   bool sync_managed = false;
   bool result = value->GetAsBoolean(&sync_managed);
   ASSERT_TRUE(result);
   EXPECT_TRUE(sync_managed);
 }
 
 // Test cases for how the DownloadDirectory and AllowFileSelectionDialogs policy
 // influence the PromptForDownload preference.
 class ConfigurationPolicyPrefStorePromptDownloadTest
     : public ConfigurationPolicyPrefStoreTest {};
 
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest, Default) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
 }
 
 #if !defined(OS_CHROMEOS)
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest, SetDownloadDirectory) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
-  provider_.AddMandatoryPolicy(key::kDownloadDirectory,
-                               base::Value::CreateStringValue(""));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kDownloadDirectory, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(""));
+  provider_.NotifyPolicyUpdated();
 
   // Setting a DownloadDirectory should disable the PromptForDownload pref.
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(prefs::kPromptForDownload,
                                                  &value));
   ASSERT_TRUE(value);
   bool prompt_for_download = true;
   bool result = value->GetAsBoolean(&prompt_for_download);
   ASSERT_TRUE(result);
   EXPECT_FALSE(prompt_for_download);
 }
 #endif  // !defined(OS_CHROMEOS)
 
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest,
        EnableFileSelectionDialogs) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
-  provider_.AddMandatoryPolicy(key::kAllowFileSelectionDialogs,
-                               base::Value::CreateBooleanValue(true));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kAllowFileSelectionDialogs, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
+  provider_.NotifyPolicyUpdated();
 
   // Allowing file-selection dialogs should not influence the PromptForDownload
   // pref.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest,
        DisableFileSelectionDialogs) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
-  provider_.AddMandatoryPolicy(key::kAllowFileSelectionDialogs,
-                               base::Value::CreateBooleanValue(false));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kAllowFileSelectionDialogs, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
+  provider_.NotifyPolicyUpdated();
 
   // Disabling file-selection dialogs should disable the PromptForDownload pref.
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(prefs::kPromptForDownload,
                                                  &value));
   ASSERT_TRUE(value);
   bool prompt_for_download = true;
   bool result = value->GetAsBoolean(&prompt_for_download);
   ASSERT_TRUE(result);
   EXPECT_FALSE(prompt_for_download);
 }
 
 // Test cases for the Autofill policy setting.
 class ConfigurationPolicyPrefStoreAutofillTest
     : public ConfigurationPolicyPrefStoreTest {};
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Default) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kAutofillEnabled, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Enabled) {
-  provider_.AddMandatoryPolicy(key::kAutoFillEnabled,
-                               base::Value::CreateBooleanValue(true));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kAutoFillEnabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateBooleanValue(true));
+  provider_.NotifyPolicyUpdated();
   // Enabling Autofill should not set the pref.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kAutofillEnabled, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Disabled) {
-  provider_.AddMandatoryPolicy(key::kAutoFillEnabled,
-                               base::Value::CreateBooleanValue(false));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kAutoFillEnabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateBooleanValue(false));
+  provider_.NotifyPolicyUpdated();
   // Disabling Autofill should switch the pref to managed.
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kAutofillEnabled, &value));
   ASSERT_TRUE(value);
   bool autofill_enabled = true;
   bool result = value->GetAsBoolean(&autofill_enabled);
   ASSERT_TRUE(result);
   EXPECT_FALSE(autofill_enabled);
 }
 
 // Exercises the policy refresh mechanism.
 class ConfigurationPolicyPrefStoreRefreshTest
     : public ConfigurationPolicyPrefStoreTest {
  protected:
   virtual void SetUp() {
     store_->AddObserver(&observer_);
   }
 
   virtual void TearDown() {
     store_->RemoveObserver(&observer_);
   }
 
+  void ResetServiceAndStore() {

[Mattias Nissler (ping if slow), 2012/04/27 09:03:27]

Since this is not declared virtual in ConfigurationPolicyPrefStoreTest, the
constructor will actually run
ConfigurationPolicyPrefStoreTest::ResetServiceAndStore(). I guess that's
intentional, but then you should use different names in the first place.

[Joao da Silva, 2012/04/27 11:24:12]

It's intentional; using different names to avoid confusion.

+    store_->RemoveObserver(&observer_);
+    ConfigurationPolicyPrefStoreTest::ResetServiceAndStore();
+    store_->AddObserver(&observer_);
+  }
+
   PrefStoreObserverMock observer_;
 };
 
 TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Refresh) {
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kHomePage, NULL));
 
   EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
-  provider_.AddMandatoryPolicy(
-      key::kHomepageLocation,
-      base::Value::CreateStringValue("http://www.chromium.org"));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kHomepageLocation, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue("http://www.chromium.org"));
+  provider_.NotifyPolicyUpdated();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kHomePage, &value));
   EXPECT_TRUE(base::StringValue("http://www.chromium.org").Equals(value));
 
   EXPECT_CALL(observer_, OnPrefValueChanged(_)).Times(0);
-  provider_.RefreshPolicies();
+  provider_.NotifyPolicyUpdated();
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
-  provider_.RemovePolicy(key::kHomepageLocation);
-  provider_.RefreshPolicies();
+  policy_.Erase(key::kHomepageLocation);
+  provider_.NotifyPolicyUpdated();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kHomePage, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Initialization) {
+  EXPECT_CALL(provider_, IsInitializationComplete())
+      .WillRepeatedly(Return(false));
+  ResetServiceAndStore();

[Mattias Nissler (ping if slow), 2012/04/27 09:03:27]

Why is this necessary?

[Joao da Silva, 2012/04/27 11:24:12]

Because store_, as created from SetUp, is already initialized (because the
provider_ is also initialized there).

[Mattias Nissler (ping if slow), 2012/04/27 12:52:58]

Can't we just initialize with IsInitializationComplete() returning false, and
then, as the last step in SetUp switch it to true (so the other tests don't
fail). Then, in this test you only need put another override to false. Would
that work?

[Joao da Silva, 2012/04/27 13:46:29]

I've realized that the store can be uninitialized on all the other tests, so
configuring IsInitializationComplete() to return false at SetUp actually works.

   EXPECT_FALSE(store_->IsInitializationComplete());
 
+  EXPECT_CALL(provider_, IsInitializationComplete())
+      .WillRepeatedly(Return(true));
   EXPECT_CALL(observer_, OnInitializationCompleted(true)).Times(1);
-
-  provider_.SetInitializationComplete(true);
-  EXPECT_FALSE(store_->IsInitializationComplete());
-
-  provider_.RefreshPolicies();
+  provider_.NotifyPolicyUpdated();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(store_->IsInitializationComplete());
 }
 
 // Tests for policies that don't quite fit the previous patterns.
 class ConfigurationPolicyPrefStoreOthersTest
     : public ConfigurationPolicyPrefStoreTest {};
 
 TEST_F(ConfigurationPolicyPrefStoreOthersTest, JavascriptEnabled) {
   // This is a boolean policy, but affects an integer preference.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
-  provider_.AddMandatoryPolicy(key::kJavascriptEnabled,
-                               base::Value::CreateBooleanValue(true));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kJavascriptEnabled, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
+  provider_.NotifyPolicyUpdated();
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
-  provider_.AddMandatoryPolicy(key::kJavascriptEnabled,
-                               base::Value::CreateBooleanValue(false));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kJavascriptEnabled, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
+  provider_.NotifyPolicyUpdated();
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, &value));
   EXPECT_TRUE(base::FundamentalValue(CONTENT_SETTING_BLOCK).Equals(value));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreOthersTest, JavascriptEnabledOverridden) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
-  provider_.AddMandatoryPolicy(key::kJavascriptEnabled,
-                               base::Value::CreateBooleanValue(false));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kJavascriptEnabled, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
+  provider_.NotifyPolicyUpdated();
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, &value));
   EXPECT_TRUE(base::FundamentalValue(CONTENT_SETTING_BLOCK).Equals(value));
   // DefaultJavaScriptSetting overrides JavascriptEnabled.
-  provider_.AddMandatoryPolicy(
-      key::kDefaultJavaScriptSetting,
-      base::Value::CreateIntegerValue(CONTENT_SETTING_ALLOW));
-  provider_.RefreshPolicies();
+  policy_.Set(key::kDefaultJavaScriptSetting, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER,
+              base::Value::CreateIntegerValue(CONTENT_SETTING_ALLOW));
+  provider_.NotifyPolicyUpdated();
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, &value));
   EXPECT_TRUE(base::FundamentalValue(CONTENT_SETTING_ALLOW).Equals(value));
 }
 
 }  // namespace policy