Remove calls to deprecated MessageLoop methods on Windows and Linux.

components/policy/core/common/configuration_policy_provider_test.cc

 // Copyright 2013 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 "components/policy/core/common/configuration_policy_provider_test.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
+#include "base/run_loop.h"
 #include "base/values.h"
 #include "components/policy/core/common/configuration_policy_provider.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_namespace.h"
 #include "components/policy/core/common/policy_test_utils.h"
 #include "components/policy/core/common/policy_types.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 113 matching lines @@
 PolicyTestBase::PolicyTestBase() {}
 
 PolicyTestBase::~PolicyTestBase() {}
 
 void PolicyTestBase::SetUp() {
   const PolicyNamespace ns(POLICY_DOMAIN_CHROME, "");
   ASSERT_TRUE(RegisterSchema(ns, kTestChromeSchema));
 }
 
 void PolicyTestBase::TearDown() {
-  loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 bool PolicyTestBase::RegisterSchema(const PolicyNamespace& ns,
                                     const std::string& schema_string) {
   std::string error;
   Schema schema = Schema::Parse(schema_string, &error);
   if (schema.valid()) {
     schema_registry_.RegisterComponent(ns, schema);
     return true;
   }
@@ skipping 48 matching lines @@
   schema_registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                       "cccccccccccccccccccccccccccccccc"),
       extension_schema);
 
   provider_.reset(
       harness_->CreateProvider(&schema_registry_, loop_.task_runner()));
   provider_->Init(&schema_registry_);
   // Some providers do a reload on init. Make sure any notifications generated
   // are fired now.
-  loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   const PolicyBundle kEmptyBundle;
   EXPECT_TRUE(provider_->policies().Equals(kEmptyBundle));
 }
 
 void ConfigurationPolicyProviderTest::TearDown() {
   // Give providers the chance to clean up after themselves on the file thread.
   if (provider_) {
     provider_->Shutdown();
     provider_.reset();
   }
 
   PolicyTestBase::TearDown();
 }
 
 void ConfigurationPolicyProviderTest::CheckValue(
     const char* policy_name,
     const base::Value& expected_value,
     base::Closure install_value) {
   // Install the value, reload policy and check the provider for the value.
   install_value.Run();
   provider_->RefreshPolicies();
-  loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   PolicyBundle expected_bundle;
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .Set(policy_name, harness_->policy_level(), harness_->policy_scope(),
            harness_->policy_source(), expected_value.CreateDeepCopy(), nullptr);
   bool match = provider_->policies().Equals(expected_bundle);
   if (!match) {
     LOG(ERROR) << "EXPECTED: " << expected_bundle;
     LOG(ERROR) << "ACTUAL: " << provider_->policies();
   }
   EXPECT_TRUE(match);
   // TODO(joaodasilva): set the policy in the POLICY_DOMAIN_EXTENSIONS too,
   // and extend the |expected_bundle|, once all providers are ready.
 }
 
 TEST_P(ConfigurationPolicyProviderTest, Empty) {
   provider_->RefreshPolicies();
-  loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   const PolicyBundle kEmptyBundle;
   EXPECT_TRUE(provider_->policies().Equals(kEmptyBundle));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, StringValue) {
   const char kTestString[] = "string_value";
   base::StringValue expected_value(kTestString);
   CheckValue(harness_->key_string(),
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallStringPolicy,
@@ skipping 70 matching lines @@
 
 TEST_P(ConfigurationPolicyProviderTest, RefreshPolicies) {
   PolicyBundle bundle;
   EXPECT_TRUE(provider_->policies().Equals(bundle));
 
   // OnUpdatePolicy is called even when there are no changes.
   MockConfigurationPolicyObserver observer;
   provider_->AddObserver(&observer);
   EXPECT_CALL(observer, OnUpdatePolicy(provider_.get())).Times(1);
   provider_->RefreshPolicies();
-  loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
 
   EXPECT_TRUE(provider_->policies().Equals(bundle));
 
   // OnUpdatePolicy is called when there are changes.
   harness_->InstallStringPolicy(harness_->key_string(), "value");
   EXPECT_CALL(observer, OnUpdatePolicy(provider_.get())).Times(1);
   provider_->RefreshPolicies();
-  loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
 
   bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .Set(harness_->key_string(), harness_->policy_level(),
            harness_->policy_scope(), harness_->policy_source(),
            base::WrapUnique(new base::StringValue("value")), nullptr);
   EXPECT_TRUE(provider_->policies().Equals(bundle));
   provider_->RemoveObserver(&observer);
 }
 
@@ skipping 29 matching lines @@
   policy_3rdparty.Set("extensions.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
                       policy_dict.DeepCopy());
   // Install invalid 3rd party policies that shouldn't be loaded. These also
   // help detecting memory leaks in the code paths that detect invalid input.
   policy_3rdparty.Set("invalid-domain.component", policy_dict.DeepCopy());
   policy_3rdparty.Set("extensions.cccccccccccccccccccccccccccccccc",
                       new base::StringValue("invalid-value"));
   harness_->Install3rdPartyPolicy(&policy_3rdparty);
 
   provider_->RefreshPolicies();
-  loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   PolicyMap expected_policy;
   expected_policy.Set(harness_->key_dictionary(), harness_->policy_level(),
                       harness_->policy_scope(), harness_->policy_source(),
                       policy_dict.CreateDeepCopy(), nullptr);
   PolicyBundle expected_bundle;
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .CopyFrom(expected_policy);
   expected_policy.Clear();
   expected_policy.LoadFrom(&policy_dict,
                            harness_->policy_level(),
                            harness_->policy_scope(),
                            harness_->policy_source());
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
       .CopyFrom(expected_policy);
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
       .CopyFrom(expected_policy);
   EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
 }
 
 }  // namespace policy