Create a list of policy changes before notifying observers

chrome/browser/policy/policy_prefs_browsertest.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 <algorithm>
 #include <map>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
+#include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 359 matching lines @@
     EXPECT_CALL(provider_, IsInitializationComplete())
         .WillRepeatedly(Return(true));
     BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
     ui_test_utils::WaitForTemplateURLServiceToLoad(
         TemplateURLServiceFactory::GetForProfile(browser()->profile()));
   }
 
+  void UpdateProviderPolicy(const PolicyMap& policy) {
+    provider_.UpdateChromePolicy(policy);
+    base::RunLoop loop;

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

#include "base/run_loop.h"

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

Done.

+    loop.RunUntilIdle();
+  }
+
   PolicyTestCases policy_test_cases_;
   MockConfigurationPolicyProvider provider_;
 };
 
 TEST(PolicyPrefsTestCoverageTest, AllPoliciesHaveATestCase) {
   // Verifies that all known policies have a test case in the JSON file.
   // This test fails when a policy is added to
   // chrome/app/policy/policy_templates.json but a test case is not added to
   // chrome/test/data/policy/policy_test_cases.json.
   PolicyTestCases policy_test_cases;
@@ skipping 29 matching lines @@
     PrefService* prefs = (*pref_mapping)->is_local_state() ?
         local_state : user_prefs;
     // The preference must have been registered.
     const PrefService::Preference* pref =
         prefs->FindPreference((*pref_mapping)->pref().c_str());
     ASSERT_TRUE(pref);
     prefs->ClearPref((*pref_mapping)->pref().c_str());
 
     // Verify that setting the policy overrides the pref.
     const PolicyMap kNoPolicies;
-    provider_.UpdateChromePolicy(kNoPolicies);
+    UpdateProviderPolicy(kNoPolicies);
     EXPECT_TRUE(pref->IsDefaultValue());
     EXPECT_TRUE(pref->IsUserModifiable());
     EXPECT_FALSE(pref->IsUserControlled());
     EXPECT_FALSE(pref->IsManaged());
 
-    provider_.UpdateChromePolicy(test_case->test_policy());
+    UpdateProviderPolicy(test_case->test_policy());
     EXPECT_FALSE(pref->IsDefaultValue());
     EXPECT_FALSE(pref->IsUserModifiable());
     EXPECT_FALSE(pref->IsUserControlled());
     EXPECT_TRUE(pref->IsManaged());
   }
 }
 
 IN_PROC_BROWSER_TEST_P(PolicyPrefsTest, CheckPolicyIndicators) {
   // Verifies that controlled setting indicators correctly show whether a pref's
   // value is recommended or enforced by a corresponding policy.
@@ skipping 38 matching lines @@
     std::string indicator_selector = (*pref_mapping)->indicator_selector();
     if (indicator_selector.empty())
       indicator_selector = "[pref=\"" + (*pref_mapping)->pref() + "\"]";
     for (ScopedVector<IndicatorTestCase>::const_iterator
              indicator_test_case = indicator_test_cases.begin();
          indicator_test_case != indicator_test_cases.end();
          ++indicator_test_case) {
       // Check that no controlled setting indicator is visible when no value is
       // set by policy.
       PolicyMap policies;
-      provider_.UpdateChromePolicy(policies);
+      UpdateProviderPolicy(policies);
       VerifyControlledSettingIndicators(browser(), indicator_selector,
                                         "", "", false);
       // Check that the appropriate controlled setting indicator is shown when a
       // value is enforced by policy.
       policies.LoadFrom(&(*indicator_test_case)->policy(),
                         POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
-      provider_.UpdateChromePolicy(policies);
+      UpdateProviderPolicy(policies);
       VerifyControlledSettingIndicators(browser(), indicator_selector,
                                         (*indicator_test_case)->value(),
                                         "policy",
                                         (*indicator_test_case)->readonly());
 
       if (!policy_test_case->can_be_recommended())
         continue;
 
       PrefService* local_state = g_browser_process->local_state();
       PrefService* user_prefs = browser()->profile()->GetPrefs();
       PrefService* prefs = (*pref_mapping)->is_local_state() ?
           local_state : user_prefs;
       // The preference must have been registered.
       const PrefService::Preference* pref =
           prefs->FindPreference((*pref_mapping)->pref().c_str());
       ASSERT_TRUE(pref);
 
       // Check that the appropriate controlled setting indicator is shown when a
       // value is recommended by policy and the user has not overridden the
       // recommendation.
       policies.LoadFrom(&(*indicator_test_case)->policy(),
                         POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER);
-      provider_.UpdateChromePolicy(policies);
+      UpdateProviderPolicy(policies);
       VerifyControlledSettingIndicators(browser(), indicator_selector,
                                         (*indicator_test_case)->value(),
                                         "recommended",
                                         (*indicator_test_case)->readonly());
       // Check that the appropriate controlled setting indicator is shown when a
       // value is recommended by policy and the user has overriddent the
       // recommendation.
       prefs->Set((*pref_mapping)->pref().c_str(), *pref->GetValue());
       VerifyControlledSettingIndicators(browser(), indicator_selector,
                                         (*indicator_test_case)->value(),
                                         "hasRecommendation",
                                         (*indicator_test_case)->readonly());
       prefs->ClearPref((*pref_mapping)->pref().c_str());
     }
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
     PolicyPrefsTestInstance,
     PolicyPrefsTest,
     testing::ValuesIn(GetChromePolicyDefinitionList()->begin,
                       GetChromePolicyDefinitionList()->end));
 
 }  // namespace policy