chrome/browser: Update calls from RunAllPending() to RunUntilIdle().

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"
@@ skipping 39 matching lines @@
   UserPolicyCacheTest()
       : loop_(MessageLoop::TYPE_UI),
         ui_thread_(BrowserThread::UI, &loop_),
         file_thread_(BrowserThread::FILE, &loop_) {}
 
   void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
   void TearDown() {
-    loop_.RunAllPending();
+    loop_.RunUntilIdle();
   }
 
   // Creates a (signed) PolicyFetchResponse setting the given |homepage| and
   // featuring the given |timestamp| (as issued by the server).
   // Mildly hacky special feature: pass an empty string as |homepage| to get
   // a completely empty policy.
   em::PolicyFetchResponse* CreateHomepagePolicy(
       const std::string& homepage,
       const base::Time& timestamp,
       const em::PolicyOptions::PolicyMode policy_mode) {
@@ skipping 136 matching lines @@
 TEST_F(UserPolicyCacheTest, Empty) {
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   PolicyMap empty;
   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();
+  loop_.RunUntilIdle();
   PolicyMap empty;
   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();
+  loop_.RunUntilIdle();
   PolicyMap empty;
   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();
+  loop_.RunUntilIdle();
   PolicyMap empty;
   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();
+  loop_.RunUntilIdle();
   PolicyMap expected;
   expected.Set(key::kHomepageLocation,
                POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, SetPolicy) {
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
@@ skipping 50 matching lines @@
 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));
     EXPECT_TRUE(cache.SetPolicy(*policy));
   }
 
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
 
   EXPECT_TRUE(file_util::PathExists(test_file()));
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.Load();
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   PolicyMap expected;
   expected.Set(key::kHomepageLocation,
                POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
   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);
   EXPECT_TRUE(SetPolicy(&cache, updated_policy));
 
   cache.Load();
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   PolicyMap expected;
   expected.Set(key::kHomepageLocation,
                POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.chromium.org"));
   EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, SetReady) {
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
@@ skipping 49 matching lines @@
                POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(SetPolicy(&cache, policy));
   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();
+  loop_.RunUntilIdle();
   EXPECT_TRUE(cache.IsReady());
 }
 
 TEST_F(UserPolicyCacheTest, CheckReadyWaitForFetch) {
   UserPolicyCache cache(test_file(), true  /* wait_for_policy_fetch */);
   EXPECT_FALSE(cache.IsReady());
   cache.Load();
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   EXPECT_FALSE(cache.IsReady());
   cache.SetFetchingDone();
   EXPECT_TRUE(cache.IsReady());
 }
 
 TEST_F(UserPolicyCacheTest, CheckReadyWaitForDisk) {
   UserPolicyCache cache(test_file(), true  /* wait_for_policy_fetch */);
   EXPECT_FALSE(cache.IsReady());
   cache.SetFetchingDone();
   EXPECT_FALSE(cache.IsReady());
   cache.Load();
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   EXPECT_TRUE(cache.IsReady());
 }
 
 }  // namespace policy