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

chrome/browser/net/pref_proxy_config_tracker_impl_unittest.cc

 // Copyright (c) 2011 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/net/pref_proxy_config_tracker_impl.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
@@ skipping 74 matching lines @@
         new TestProxyConfigService(fixed_config_,
                                    net::ProxyConfigService::CONFIG_VALID);
     proxy_config_service_.reset(
         new ChromeProxyConfigService(delegate_service_, true));
     proxy_config_tracker_.reset(new PrefProxyConfigTrackerImpl(pref_service));
     proxy_config_tracker_->SetChromeProxyConfigService(
         proxy_config_service_.get());
     // SetChromeProxyConfigService triggers update of initial prefs proxy
     // config by tracker to chrome proxy config service, so flush all pending
     // tasks so that tests start fresh.
-    loop_.RunAllPending();
+    loop_.RunUntilIdle();
   }
 
   virtual void TearDown() {
     proxy_config_tracker_->DetachFromPrefService();
-    loop_.RunAllPending();
+    loop_.RunUntilIdle();
     proxy_config_tracker_.reset();
     proxy_config_service_.reset();
   }
 
   MessageLoop loop_;
   TestProxyConfigService* delegate_service_; // weak
   scoped_ptr<ChromeProxyConfigService> proxy_config_service_;
   net::ProxyConfig fixed_config_;
 
  private:
@@ skipping 17 matching lines @@
   net::ProxyConfig actual_config;
   EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&actual_config));
   EXPECT_EQ(GURL(kFixedPacUrl), actual_config.pac_url());
 }
 
 TEST_F(PrefProxyConfigTrackerImplTest, DynamicPrefOverrides) {
   pref_service_->SetManagedPref(
       prefs::kProxy,
       ProxyConfigDictionary::CreateFixedServers("http://example.com:3128", ""));
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
 
   net::ProxyConfig actual_config;
   EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&actual_config));
   EXPECT_FALSE(actual_config.auto_detect());
   EXPECT_EQ(net::ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY,
             actual_config.proxy_rules().type);
   EXPECT_EQ(actual_config.proxy_rules().single_proxy,
             net::ProxyServer::FromURI("http://example.com:3128",
                                       net::ProxyServer::SCHEME_HTTP));
 
   pref_service_->SetManagedPref(prefs::kProxy,
                                 ProxyConfigDictionary::CreateAutoDetect());
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
 
   EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&actual_config));
   EXPECT_TRUE(actual_config.auto_detect());
 }
 
 // Compares proxy configurations, but allows different identifiers.
 MATCHER_P(ProxyConfigMatches, config, "") {
   net::ProxyConfig reference(config);
   reference.set_id(arg.id());
   return reference.Equals(arg);
 }
 
 TEST_F(PrefProxyConfigTrackerImplTest, Observers) {
   const net::ProxyConfigService::ConfigAvailability CONFIG_VALID =
       net::ProxyConfigService::CONFIG_VALID;
   MockObserver observer;
   proxy_config_service_->AddObserver(&observer);
 
   // Firing the observers in the delegate should trigger a notification.
   net::ProxyConfig config2;
   config2.set_auto_detect(true);
   EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(config2),
                                              CONFIG_VALID)).Times(1);
   delegate_service_->SetProxyConfig(config2, CONFIG_VALID);
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
 
   // Override configuration, this should trigger a notification.
   net::ProxyConfig pref_config;
   pref_config.set_pac_url(GURL(kFixedPacUrl));
 
   EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(pref_config),
                                              CONFIG_VALID)).Times(1);
   pref_service_->SetManagedPref(
       prefs::kProxy,
       ProxyConfigDictionary::CreatePacScript(kFixedPacUrl, false));
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
 
   // Since there are pref overrides, delegate changes should be ignored.
   net::ProxyConfig config3;
   config3.proxy_rules().ParseFromString("http=config3:80");
   EXPECT_CALL(observer, OnProxyConfigChanged(_, _)).Times(0);
   fixed_config_.set_auto_detect(true);
   delegate_service_->SetProxyConfig(config3, CONFIG_VALID);
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
 
   // Clear the override should switch back to the fixed configuration.
   EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(config3),
                                              CONFIG_VALID)).Times(1);
   pref_service_->RemoveManagedPref(prefs::kProxy);
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
 
   // Delegate service notifications should show up again.
   net::ProxyConfig config4;
   config4.proxy_rules().ParseFromString("socks:config4");
   EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(config4),
                                              CONFIG_VALID)).Times(1);
   delegate_service_->SetProxyConfig(config4, CONFIG_VALID);
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
 
   proxy_config_service_->RemoveObserver(&observer);
 }
 
 TEST_F(PrefProxyConfigTrackerImplTest, Fallback) {
   const net::ProxyConfigService::ConfigAvailability CONFIG_VALID =
       net::ProxyConfigService::CONFIG_VALID;
   MockObserver observer;
   net::ProxyConfig actual_config;
   delegate_service_->SetProxyConfig(net::ProxyConfig::CreateDirect(),
                                     net::ProxyConfigService::CONFIG_UNSET);
   proxy_config_service_->AddObserver(&observer);
 
   // Prepare test data.
   net::ProxyConfig recommended_config = net::ProxyConfig::CreateAutoDetect();
   net::ProxyConfig user_config =
       net::ProxyConfig::CreateFromCustomPacURL(GURL(kFixedPacUrl));
 
   // Set a recommended pref.
   EXPECT_CALL(observer,
               OnProxyConfigChanged(ProxyConfigMatches(recommended_config),
                                    CONFIG_VALID)).Times(1);
   pref_service_->SetRecommendedPref(
       prefs::kProxy,
       ProxyConfigDictionary::CreateAutoDetect());
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
   EXPECT_EQ(CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&actual_config));
   EXPECT_TRUE(actual_config.Equals(recommended_config));
 
   // Override in user prefs.
   EXPECT_CALL(observer,
               OnProxyConfigChanged(ProxyConfigMatches(user_config),
                                    CONFIG_VALID)).Times(1);
   pref_service_->SetManagedPref(
       prefs::kProxy,
       ProxyConfigDictionary::CreatePacScript(kFixedPacUrl, false));
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
   EXPECT_EQ(CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&actual_config));
   EXPECT_TRUE(actual_config.Equals(user_config));
 
   // Go back to recommended pref.
   EXPECT_CALL(observer,
               OnProxyConfigChanged(ProxyConfigMatches(recommended_config),
                                    CONFIG_VALID)).Times(1);
   pref_service_->RemoveManagedPref(prefs::kProxy);
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
   EXPECT_EQ(CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&actual_config));
   EXPECT_TRUE(actual_config.Equals(recommended_config));
 
   proxy_config_service_->RemoveObserver(&observer);
 }
 
 TEST_F(PrefProxyConfigTrackerImplTest, ExplicitSystemSettings) {
   pref_service_->SetRecommendedPref(
       prefs::kProxy,
       ProxyConfigDictionary::CreateAutoDetect());
   pref_service_->SetUserPref(
       prefs::kProxy,
       ProxyConfigDictionary::CreateSystem());
-  loop_.RunAllPending();
+  loop_.RunUntilIdle();
 
   // Test if we actually use the system setting, which is |kFixedPacUrl|.
   net::ProxyConfig actual_config;
   EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&actual_config));
   EXPECT_EQ(GURL(kFixedPacUrl), actual_config.pac_url());
 }
 
 // Test parameter object for testing command line proxy configuration.
 struct CommandLineTestParams {
@@ skipping 179 matching lines @@
     net::ProxyRulesExpectation::Empty(),
   },
 };
 
 INSTANTIATE_TEST_CASE_P(
     PrefProxyConfigTrackerImplCommandLineTestInstance,
     PrefProxyConfigTrackerImplCommandLineTest,
     testing::ValuesIn(kCommandLineTestParams));
 
 }  // namespace