Use ScopedTaskEnvironment instead of MessageLoopForUI in components tests.

components/policy/core/common/cloud/user_cloud_policy_store_unittest.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/cloud/user_cloud_policy_store.h"
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
+#include "base/test/scoped_task_environment.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/mock_cloud_external_data_manager.h"
 #include "components/policy/core/common/cloud/mock_cloud_policy_store.h"
 #include "components/policy/core/common/cloud/policy_builder.h"
 #include "components/policy/core/common/policy_switches.h"
 #include "components/policy/policy_constants.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 24 matching lines @@
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
 class UserCloudPolicyStoreTest : public testing::Test {
  public:
-  UserCloudPolicyStoreTest() {}
+  UserCloudPolicyStoreTest()
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI) {}
 
   void SetUp() override {
     ASSERT_TRUE(tmp_dir_.CreateUniqueTempDir());
     store_.reset(new UserCloudPolicyStore(policy_file(), key_file(),
-                                          loop_.task_runner()));
+                                          base::ThreadTaskRunnerHandle::Get()));
     external_data_manager_.reset(new MockCloudExternalDataManager);
     external_data_manager_->SetPolicyStore(store_.get());
     store_->SetSigninUsername(PolicyBuilder::kFakeUsername);
     EXPECT_EQ(PolicyBuilder::kFakeUsername, store_->signin_username());
     store_->AddObserver(&observer_);
 
     // Install an initial public key, so that by default the validation of
     // the stored/loaded policy blob succeeds (it looks like a new key
     // provision).
     policy_.SetDefaultInitialSigningKey();
@@ skipping 52 matching lines @@
     Mock::VerifyAndClearExpectations(external_data_manager_.get());
     Mock::VerifyAndClearExpectations(&observer_);
     ASSERT_TRUE(store_->policy());
   }
 
   UserPolicyBuilder policy_;
   MockCloudPolicyStoreObserver observer_;
   std::unique_ptr<UserCloudPolicyStore> store_;
   std::unique_ptr<MockCloudExternalDataManager> external_data_manager_;
 
-  // CloudPolicyValidator() requires a FILE thread so declare one here. Both
-  // |ui_thread_| and |file_thread_| share the same MessageLoop |loop_| so
-  // callers can use RunLoop to manage both virtual threads.
-  base::MessageLoopForUI loop_;
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
 
   base::ScopedTempDir tmp_dir_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UserCloudPolicyStoreTest);
 };
 
 TEST_F(UserCloudPolicyStoreTest, LoadWithNoFile) {
   EXPECT_FALSE(store_->policy());
   EXPECT_TRUE(store_->policy_map().empty());
@@ skipping 199 matching lines @@
   EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status());
 }
 
 TEST_F(UserCloudPolicyStoreTest, StoreThenLoad) {
   // Store a simple policy and make sure it can be read back in.
   // policy.
   StorePolicyAndEnsureLoaded(policy_.policy());
   EXPECT_FALSE(store_->policy_signature_public_key().empty());
 
   // Now, make sure the policy can be read back in from a second store.
-  std::unique_ptr<UserCloudPolicyStore> store2(
-      new UserCloudPolicyStore(policy_file(), key_file(), loop_.task_runner()));
+  std::unique_ptr<UserCloudPolicyStore> store2(new UserCloudPolicyStore(
+      policy_file(), key_file(), base::ThreadTaskRunnerHandle::Get()));
   store2->SetSigninUsername(PolicyBuilder::kFakeUsername);
   store2->AddObserver(&observer_);
   EXPECT_CALL(observer_, OnStoreLoaded(store2.get()));
   store2->Load();
   RunUntilIdle();
 
   ASSERT_TRUE(store2->policy());
   EXPECT_EQ(policy_.policy_data().SerializeAsString(),
             store2->policy()->SerializeAsString());
   VerifyPolicyMap(store2.get());
   EXPECT_EQ(CloudPolicyStore::STATUS_OK, store2->status());
   store2->RemoveObserver(&observer_);
   // Make sure that we properly resurrected the keys.
   EXPECT_EQ(store2->policy_signature_public_key(),
             store_->policy_signature_public_key());
 }
 
 TEST_F(UserCloudPolicyStoreTest, StoreThenLoadImmediately) {
   // Store a simple policy and make sure it can be read back in.
   // policy.
   StorePolicyAndEnsureLoaded(policy_.policy());
 
   // Now, make sure the policy can be read back in from a second store.
-  std::unique_ptr<UserCloudPolicyStore> store2(
-      new UserCloudPolicyStore(policy_file(), key_file(), loop_.task_runner()));
+  std::unique_ptr<UserCloudPolicyStore> store2(new UserCloudPolicyStore(
+      policy_file(), key_file(), base::ThreadTaskRunnerHandle::Get()));
   store2->SetSigninUsername(PolicyBuilder::kFakeUsername);
   store2->AddObserver(&observer_);
   EXPECT_CALL(observer_, OnStoreLoaded(store2.get()));
   store2->LoadImmediately();  // Should load without running the message loop.
 
   ASSERT_TRUE(store2->policy());
   EXPECT_EQ(policy_.policy_data().SerializeAsString(),
             store2->policy()->SerializeAsString());
   VerifyPolicyMap(store2.get());
   EXPECT_EQ(CloudPolicyStore::STATUS_OK, store2->status());
@@ skipping 22 matching lines @@
   RunUntilIdle();
   ASSERT_FALSE(store_->policy());
 }
 
 TEST_F(UserCloudPolicyStoreTest, LoadValidationError) {
   // Force a validation error by changing the username after policy is stored.
   StorePolicyAndEnsureLoaded(policy_.policy());
 
   // Sign out, and sign back in as a different user, and try to load the profile
   // data (should fail due to mismatched username).
-  std::unique_ptr<UserCloudPolicyStore> store2(
-      new UserCloudPolicyStore(policy_file(), key_file(), loop_.task_runner()));
+  std::unique_ptr<UserCloudPolicyStore> store2(new UserCloudPolicyStore(
+      policy_file(), key_file(), base::ThreadTaskRunnerHandle::Get()));
   store2->SetSigninUsername("foobar@foobar.com");
   store2->AddObserver(&observer_);
   ExpectError(store2.get(), CloudPolicyStore::STATUS_VALIDATION_ERROR);
   store2->Load();
   RunUntilIdle();
 
   ASSERT_FALSE(store2->policy());
   store2->RemoveObserver(&observer_);
 
   // Sign out - we should be able to load the policy (don't check usernames
   // when signed out).
-  std::unique_ptr<UserCloudPolicyStore> store3(
-      new UserCloudPolicyStore(policy_file(), key_file(), loop_.task_runner()));
+  std::unique_ptr<UserCloudPolicyStore> store3(new UserCloudPolicyStore(
+      policy_file(), key_file(), base::ThreadTaskRunnerHandle::Get()));
   store3->AddObserver(&observer_);
   EXPECT_CALL(observer_, OnStoreLoaded(store3.get()));
   store3->Load();
   RunUntilIdle();
 
   ASSERT_TRUE(store3->policy());
   store3->RemoveObserver(&observer_);
 
   // Now start a signin as a different user - this should fail validation.
-  std::unique_ptr<UserCloudPolicyStore> store4(
-      new UserCloudPolicyStore(policy_file(), key_file(), loop_.task_runner()));
+  std::unique_ptr<UserCloudPolicyStore> store4(new UserCloudPolicyStore(
+      policy_file(), key_file(), base::ThreadTaskRunnerHandle::Get()));
   store4->SetSigninUsername("foobar@foobar.com");
   store4->AddObserver(&observer_);
   ExpectError(store4.get(), CloudPolicyStore::STATUS_VALIDATION_ERROR);
   store4->Load();
   RunUntilIdle();
 
   ASSERT_FALSE(store4->policy());
   store4->RemoveObserver(&observer_);
 }
 
 TEST_F(UserCloudPolicyStoreTest, KeyRotation) {
   // Make sure when we load data from disk with a different key, that we trigger
   // a server-side key rotation.
   StorePolicyAndEnsureLoaded(policy_.policy());
   ASSERT_TRUE(store_->policy()->has_public_key_version());
 
   std::string key_data;
   enterprise_management::PolicySigningKey key;
   ASSERT_TRUE(base::ReadFileToString(key_file(), &key_data));
   ASSERT_TRUE(key.ParseFromString(key_data));
   key.set_verification_key("different_key");
   key.SerializeToString(&key_data);
   WriteStringToFile(key_file(), key_data);
 
   // Now load this in a new store - this should trigger key rotation. The keys
   // will still verify using the existing verification key.
-  std::unique_ptr<UserCloudPolicyStore> store2(
-      new UserCloudPolicyStore(policy_file(), key_file(), loop_.task_runner()));
+  std::unique_ptr<UserCloudPolicyStore> store2(new UserCloudPolicyStore(
+      policy_file(), key_file(), base::ThreadTaskRunnerHandle::Get()));
   store2->SetSigninUsername(PolicyBuilder::kFakeUsername);
   store2->AddObserver(&observer_);
   EXPECT_CALL(observer_, OnStoreLoaded(store2.get()));
   store2->Load();
   RunUntilIdle();
   ASSERT_TRUE(store2->policy());
   ASSERT_FALSE(store2->policy()->has_public_key_version());
   store2->RemoveObserver(&observer_);
 }
 
 TEST_F(UserCloudPolicyStoreTest, InvalidCachedVerificationSignature) {
   // Make sure that we reject code with an invalid key.
   StorePolicyAndEnsureLoaded(policy_.policy());
 
   std::string key_data;
   enterprise_management::PolicySigningKey key;
   ASSERT_TRUE(base::ReadFileToString(key_file(), &key_data));
   ASSERT_TRUE(key.ParseFromString(key_data));
   key.set_signing_key_signature("different_key");
   key.SerializeToString(&key_data);
   WriteStringToFile(key_file(), key_data);
 
   // Now load this in a new store - this should cause a validation error because
   // the key won't verify.
-  std::unique_ptr<UserCloudPolicyStore> store2(
-      new UserCloudPolicyStore(policy_file(), key_file(), loop_.task_runner()));
+  std::unique_ptr<UserCloudPolicyStore> store2(new UserCloudPolicyStore(
+      policy_file(), key_file(), base::ThreadTaskRunnerHandle::Get()));
   store2->SetSigninUsername(PolicyBuilder::kFakeUsername);
   store2->AddObserver(&observer_);
   ExpectError(store2.get(), CloudPolicyStore::STATUS_VALIDATION_ERROR);
   store2->Load();
   RunUntilIdle();
   store2->RemoveObserver(&observer_);
 }
 
 }  // namespace policy