Create a list of policy changes before notifying observers

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 "base/message_loop.h"
 #include "base/prefs/pref_store_observer_mock.h"
+#include "base/run_loop.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 "policy/policy_constants.h"
@@ skipping 16 matching lines @@
   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() {
+  ConfigurationPolicyPrefStoreTest() : loop_(MessageLoop::TYPE_UI) {

[Joao da Silva, 2013/01/07 09:23:52]

I think the default loop type works for this test, does it have to be TYPE_UI?
(same for other tests)

[Andrew T Wilson (Slow), 2013/01/07 14:11:32]

Done.

     EXPECT_CALL(provider_, IsInitializationComplete())
         .WillRepeatedly(Return(false));
     provider_.Init();
     PolicyServiceImpl::Providers providers;
     providers.push_back(&provider_);
     policy_service_.reset(new PolicyServiceImpl(providers));
     store_ = new ConfigurationPolicyPrefStore(policy_service_.get(),
                                               POLICY_LEVEL_MANDATORY);
   }
 
   virtual void TearDown() OVERRIDE {
     provider_.Shutdown();
   }
 
+  void UpdateProviderPolicy(const PolicyMap& policy) {
+    provider_.UpdateChromePolicy(policy);
+    base::RunLoop loop;
+    loop.RunUntilIdle();
+  }
+
   MockConfigurationPolicyProvider provider_;
   scoped_ptr<PolicyServiceImpl> policy_service_;
   scoped_refptr<ConfigurationPolicyPrefStore> store_;
+  MessageLoop loop_;
 };
 
 // Test cases for list-valued policy settings.
 class ConfigurationPolicyPrefStoreListTest
     : public ConfigurationPolicyPrefStoreTest,
       public testing::WithParamInterface<PolicyAndPref> {};
 
 TEST_P(ConfigurationPolicyPrefStoreListTest, GetDefault) {
   EXPECT_FALSE(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,"));
   PolicyMap policy;
   policy.Set(GetParam().policy_name(), POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, in_value);
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   const base::Value* value = NULL;
   EXPECT_TRUE(store_->GetValue(GetParam().pref_name(), &value));
   ASSERT_TRUE(value);
   EXPECT_TRUE(in_value->Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreListTestInstance,
     ConfigurationPolicyPrefStoreListTest,
     testing::Values(
@@ skipping 21 matching lines @@
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) {
   EXPECT_FALSE(store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) {
   PolicyMap policy;
   policy.Set(GetParam().policy_name(), POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER,
              base::Value::CreateStringValue("http://chromium.org"));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   const base::Value* value = NULL;
   EXPECT_TRUE(store_->GetValue(GetParam().pref_name(), &value));
   ASSERT_TRUE(value);
   EXPECT_TRUE(base::StringValue("http://chromium.org").Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreStringTestInstance,
     ConfigurationPolicyPrefStoreStringTest,
     testing::Values(
@@ skipping 28 matching lines @@
       public testing::WithParamInterface<PolicyAndPref> {};
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, GetDefault) {
   EXPECT_FALSE(store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, SetValue) {
   PolicyMap policy;
   policy.Set(GetParam().policy_name(), POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   const base::Value* value = NULL;
   EXPECT_TRUE(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);
 
   policy.Set(GetParam().policy_name(), POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   value = NULL;
   EXPECT_TRUE(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(
     ConfigurationPolicyPrefStoreBooleanTestInstance,
@@ skipping 107 matching lines @@
       public testing::WithParamInterface<PolicyAndPref> {};
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, GetDefault) {
   EXPECT_FALSE(store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, SetValue) {
   PolicyMap policy;
   policy.Set(GetParam().policy_name(), POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateIntegerValue(2));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   const base::Value* value = NULL;
   EXPECT_TRUE(store_->GetValue(GetParam().pref_name(), &value));
   EXPECT_TRUE(base::FundamentalValue(2).Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreIntegerTestInstance,
     ConfigurationPolicyPrefStoreIntegerTest,
     testing::Values(
         PolicyAndPref(key::kDefaultCookiesSetting,
@@ skipping 62 matching lines @@
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
   PolicyMap policy;
   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_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
 
   VerifyProxyPrefs(
       "chromium.org", "", "http://chromium.org/override",
       ProxyPrefs::MODE_FIXED_SERVERS);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsReversedApplyOrder) {
   PolicyMap policy;
   policy.Set(
       key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       base::Value::CreateIntegerValue(
           ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE));
   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_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
 
   VerifyProxyPrefs(
       "chromium.org", "", "http://chromium.org/override",
       ProxyPrefs::MODE_FIXED_SERVERS);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsInvalid) {
   PolicyMap policy;
   policy.Set(
       key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       base::Value::CreateIntegerValue(
           ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
 
   const base::Value* value = NULL;
   EXPECT_FALSE(store_->GetValue(prefs::kProxy, &value));
 }
 
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyServerMode) {
   PolicyMap policy;
   policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              base::Value::CreateIntegerValue(
                  ProxyPolicyHandler::PROXY_SERVER_MODE));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_DIRECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyModeName) {
   PolicyMap policy;
   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              base::Value::CreateStringValue(ProxyPrefs::kDirectProxyModeName));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_DIRECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectProxyServerMode) {
   PolicyMap policy;
   policy.Set(
       key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       base::Value::CreateIntegerValue(
           ProxyPolicyHandler::PROXY_AUTO_DETECT_PROXY_SERVER_MODE));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectProxyModeName) {
   PolicyMap policy;
   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              base::Value::CreateStringValue(
                  ProxyPrefs::kAutoDetectProxyModeName));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyMode) {
   PolicyMap policy;
   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_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   VerifyProxyPrefs("", "http://short.org/proxy.pac", "",
                    ProxyPrefs::MODE_PAC_SCRIPT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyModeInvalid) {
   PolicyMap policy;
   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              base::Value::CreateStringValue(
                  ProxyPrefs::kPacScriptProxyModeName));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   const base::Value* value = NULL;
   EXPECT_FALSE(store_->GetValue(prefs::kProxy, &value));
 }
 
 // Regression test for http://crbug.com/78016, CPanel returns empty strings
 // for unset properties.
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyModeBug78016) {
   PolicyMap policy;
   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_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   VerifyProxyPrefs("", "http://short.org/proxy.pac", "",
                    ProxyPrefs::MODE_PAC_SCRIPT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemProxyServerMode) {
   PolicyMap policy;
   policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       base::Value::CreateIntegerValue(
           ProxyPolicyHandler::PROXY_USE_SYSTEM_PROXY_SERVER_MODE));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_SYSTEM);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemProxyMode) {
   PolicyMap policy;
   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              base::Value::CreateStringValue(ProxyPrefs::kSystemProxyModeName));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_SYSTEM);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest,
        ProxyModeOverridesProxyServerMode) {
   PolicyMap policy;
   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_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   VerifyProxyPrefs("", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ProxyInvalid) {
   // No mode expects all three parameters being set.
   PolicyMap policy;
   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) {
     policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER, base::Value::CreateIntegerValue(i));
-    provider_.UpdateChromePolicy(policy);
+    UpdateProviderPolicy(policy);
     const base::Value* value = NULL;
     EXPECT_FALSE(store_->GetValue(prefs::kProxy, &value));
   }
 }
 
 class ConfigurationPolicyPrefStoreDefaultSearchTest
     : public ConfigurationPolicyPrefStoreTest {
  public:
   ConfigurationPolicyPrefStoreDefaultSearchTest() {
     default_alternate_urls_.AppendString(
@@ skipping 58 matching lines @@
 }
 
 // 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) {
   PolicyMap policy;
   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(kSearchURL));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
 
   const base::Value* value = NULL;
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
   EXPECT_TRUE(base::StringValue(kSearchURL).Equals(value));
 
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderName, &value));
   EXPECT_TRUE(base::StringValue("test.com").Equals(value));
 
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, &value));
   EXPECT_TRUE(base::StringValue("test.com").Equals(value));
@@ skipping 20 matching lines @@
       store_->GetValue(prefs::kDefaultSearchProviderSearchTermsReplacementKey,
       &value));
   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 }
 
 // Checks that for a fully defined search policy, all elements have been
 // read properly.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
   PolicyMap policy;
   BuildDefaultSearchPolicy(&policy);
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
 
   const base::Value* value = NULL;
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
   EXPECT_TRUE(base::StringValue(kSearchURL).Equals(value));
 
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderName, &value));
   EXPECT_TRUE(base::StringValue(kName).Equals(value));
 
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, &value));
   EXPECT_TRUE(base::StringValue(kKeyword).Equals(value));
@@ skipping 17 matching lines @@
       &value));
   EXPECT_TRUE(base::StringValue(kReplacementKey).Equals(value));
 }
 
 // Checks that if the default search policy is missing, that no elements of the
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MissingUrl) {
   PolicyMap policy;
   BuildDefaultSearchPolicy(&policy);
   policy.Erase(key::kDefaultSearchProviderSearchURL);
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
 
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
                                 NULL));
   EXPECT_FALSE(store_->GetValue(
       prefs::kDefaultSearchProviderSearchTermsReplacementKey, 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) {
   PolicyMap policy;
   BuildDefaultSearchPolicy(&policy);
   const char* const bad_search_url = "http://test.com/noSearchTerms";
   policy.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER,
              base::Value::CreateStringValue(bad_search_url));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
 
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
                                 NULL));
   EXPECT_FALSE(store_->GetValue(
       prefs::kDefaultSearchProviderSearchTermsReplacementKey, 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) {
   PolicyMap policy;
   policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
 
   const base::Value* value = NULL;
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderEnabled, &value));
   base::FundamentalValue expected_enabled(false);
   EXPECT_TRUE(base::Value::Equals(&expected_enabled, value));
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
   base::StringValue expected_search_url("");
   EXPECT_TRUE(base::Value::Equals(&expected_search_url, value));
 }
 
@@ skipping 16 matching lines @@
       policy.Set(key::kIncognitoEnabled, POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER,
                  base::Value::CreateBooleanValue(
                      incognito_enabled == INCOGNITO_ENABLED_TRUE));
     }
     if (availability >= 0) {
       policy.Set(key::kIncognitoModeAvailability, POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER,
                  base::Value::CreateIntegerValue(availability));
     }
-    provider_.UpdateChromePolicy(policy);
+    UpdateProviderPolicy(policy);
   }
 
   void VerifyValues(IncognitoModePrefs::Availability availability) {
     const base::Value* value = NULL;
     EXPECT_TRUE(store_->GetValue(prefs::kIncognitoModeAvailability, &value));
     EXPECT_TRUE(base::FundamentalValue(availability).Equals(value));
   }
 };
 
 // The following testcases verify that if the obsolete IncognitoEnabled
@@ skipping 56 matching lines @@
     : public ConfigurationPolicyPrefStoreTest {};
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Default) {
   EXPECT_FALSE(store_->GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
   PolicyMap policy;
   policy.Set(key::kSyncDisabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              base::Value::CreateBooleanValue(false));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   // Enabling Sync should not set the pref.
   EXPECT_FALSE(store_->GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Disabled) {
   PolicyMap policy;
   policy.Set(key::kSyncDisabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              base::Value::CreateBooleanValue(true));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   // Sync should be flagged as managed.
   const base::Value* value = NULL;
   EXPECT_TRUE(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_FALSE(store_->GetValue(prefs::kPromptForDownload, NULL));
 }
 
 #if !defined(OS_CHROMEOS)
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest, SetDownloadDirectory) {
   PolicyMap policy;
   EXPECT_FALSE(store_->GetValue(prefs::kPromptForDownload, NULL));
   policy.Set(key::kDownloadDirectory, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateStringValue(""));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
 
   // Setting a DownloadDirectory should disable the PromptForDownload pref.
   const base::Value* value = NULL;
   EXPECT_TRUE(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) {
   PolicyMap policy;
   EXPECT_FALSE(store_->GetValue(prefs::kPromptForDownload, NULL));
   policy.Set(key::kAllowFileSelectionDialogs, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
 
   // Allowing file-selection dialogs should not influence the PromptForDownload
   // pref.
   EXPECT_FALSE(store_->GetValue(prefs::kPromptForDownload, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest,
        DisableFileSelectionDialogs) {
   PolicyMap policy;
   EXPECT_FALSE(store_->GetValue(prefs::kPromptForDownload, NULL));
   policy.Set(key::kAllowFileSelectionDialogs, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
 
   // Disabling file-selection dialogs should disable the PromptForDownload pref.
   const base::Value* value = NULL;
   EXPECT_TRUE(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_FALSE(store_->GetValue(prefs::kAutofillEnabled, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Enabled) {
   PolicyMap policy;
   policy.Set(key::kAutoFillEnabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              base::Value::CreateBooleanValue(true));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   // Enabling Autofill should not set the pref.
   EXPECT_FALSE(store_->GetValue(prefs::kAutofillEnabled, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Disabled) {
   PolicyMap policy;
   policy.Set(key::kAutoFillEnabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              base::Value::CreateBooleanValue(false));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   // Disabling Autofill should switch the pref to managed.
   const base::Value* value = NULL;
   EXPECT_TRUE(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);
 }
 
@@ skipping 15 matching lines @@
 };
 
 TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Refresh) {
   const base::Value* value = NULL;
   EXPECT_FALSE(store_->GetValue(prefs::kHomePage, NULL));
 
   EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
   PolicyMap policy;
   policy.Set(key::kHomepageLocation, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              base::Value::CreateStringValue("http://www.chromium.org"));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(store_->GetValue(prefs::kHomePage, &value));
   EXPECT_TRUE(base::StringValue("http://www.chromium.org").Equals(value));
 
   EXPECT_CALL(observer_, OnPrefValueChanged(_)).Times(0);
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
   policy.Erase(key::kHomepageLocation);
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_FALSE(store_->GetValue(prefs::kHomePage, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Initialization) {
   EXPECT_FALSE(store_->IsInitializationComplete());
   EXPECT_CALL(provider_, IsInitializationComplete())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(observer_, OnInitializationCompleted(true)).Times(1);
   PolicyMap policy;
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   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_FALSE(store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
   PolicyMap policy;
   policy.Set(key::kJavascriptEnabled, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   EXPECT_FALSE(store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
   policy.Set(key::kJavascriptEnabled, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   const base::Value* value = NULL;
   EXPECT_TRUE(store_->GetValue(prefs::kManagedDefaultJavaScriptSetting,
                                &value));
   EXPECT_TRUE(base::FundamentalValue(CONTENT_SETTING_BLOCK).Equals(value));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreOthersTest, JavascriptEnabledOverridden) {
   EXPECT_FALSE(store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
   PolicyMap policy;
   policy.Set(key::kJavascriptEnabled, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   const base::Value* value = NULL;
   EXPECT_TRUE(store_->GetValue(prefs::kManagedDefaultJavaScriptSetting,
                                &value));
   EXPECT_TRUE(base::FundamentalValue(CONTENT_SETTING_BLOCK).Equals(value));
   // DefaultJavaScriptSetting overrides JavascriptEnabled.
   policy.Set(key::kDefaultJavaScriptSetting, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER,
              base::Value::CreateIntegerValue(CONTENT_SETTING_ALLOW));
-  provider_.UpdateChromePolicy(policy);
+  UpdateProviderPolicy(policy);
   EXPECT_TRUE(store_->GetValue(prefs::kManagedDefaultJavaScriptSetting,
                                &value));
   EXPECT_TRUE(base::FundamentalValue(CONTENT_SETTING_ALLOW).Equals(value));
 }
 
 }  // namespace policy