Introduce ThreadTaskRunnerHandle::OverrideForTesting and TestMockTimeTaskRunner::ScopedContext.

components/password_manager/core/browser/affiliated_match_helper_unittest.cc

 // Copyright 2015 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/password_manager/core/browser/affiliated_match_helper.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/test/test_simple_task_runner.h"
+#include "base/test/scoped_mock_time_message_loop_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/password_manager/core/browser/affiliation_service.h"
 #include "components/password_manager/core/browser/affiliation_utils.h"
 #include "components/password_manager/core/browser/test_password_store.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace password_manager {
 
 namespace {
@@ skipping 130 matching lines @@
                                                  const char* origin) {
   return {autofill::PasswordForm::SCHEME_HTML, signon_realm,
           origin ? GURL(origin) : GURL()};
 }
 
 }  // namespace
 
 class AffiliatedMatchHelperTest : public testing::Test {
  public:
   AffiliatedMatchHelperTest()
-      : waiting_task_runner_(new base::TestSimpleTaskRunner),
-        expecting_result_callback_(false),
-        mock_affiliation_service_(nullptr) {}
+      : expecting_result_callback_(false), mock_affiliation_service_(nullptr) {}
   ~AffiliatedMatchHelperTest() override {}
 
  protected:
   void RunDeferredInitialization() {
-    base::TimeDelta expected_init_delay = base::TimeDelta::FromSeconds(
-        AffiliatedMatchHelper::kInitializationDelayOnStartupInSeconds);
-    ASSERT_TRUE(waiting_task_runner()->HasPendingTask());
-    ASSERT_EQ(expected_init_delay,
-              waiting_task_runner()->NextPendingTaskDelay());
-    waiting_task_runner()->RunUntilIdle();
-    base::RunLoop().RunUntilIdle();
+    mock_time_task_runner_->RunUntilIdle();
+    ASSERT_EQ(AffiliatedMatchHelper::kInitializationDelayOnStartup,
+              mock_time_task_runner_->NextPendingTaskDelay());
+    mock_time_task_runner_->FastForwardBy(
+        AffiliatedMatchHelper::kInitializationDelayOnStartup);
+  }
+
+  void RunUntilIdle() {
+    // TODO(gab): Add support for base::RunLoop().RunUntilIdle() in scope of
+    // ScopedMockTimeMessageLoopTaskRunner and use it instead of this helper
+    // method.
+    mock_time_task_runner_->RunUntilIdle();
   }
 
   void AddLogin(const autofill::PasswordForm& form) {
     password_store_->AddLogin(form);
-    base::RunLoop().RunUntilIdle();
+    RunUntilIdle();
   }
 
   void UpdateLoginWithPrimaryKey(
       const autofill::PasswordForm& new_form,
       const autofill::PasswordForm& old_primary_key) {
     password_store_->UpdateLoginWithPrimaryKey(new_form, old_primary_key);
-    base::RunLoop().RunUntilIdle();
+    RunUntilIdle();
   }
 
   void RemoveLogin(const autofill::PasswordForm& form) {
     password_store_->RemoveLogin(form);
-    base::RunLoop().RunUntilIdle();
+    RunUntilIdle();
   }
 
   void AddAndroidAndNonAndroidTestLogins() {
     AddLogin(GetTestAndroidCredentials(kTestAndroidRealmAlpha3));
     AddLogin(GetTestAndroidCredentials(kTestAndroidRealmBeta2));
     AddLogin(GetTestBlacklistedAndroidCredentials(kTestAndroidRealmBeta3));
     AddLogin(GetTestAndroidCredentials(kTestAndroidRealmGamma));
 
     AddLogin(GetTestAndroidCredentials(kTestWebRealmAlpha1));
     AddLogin(GetTestAndroidCredentials(kTestWebRealmAlpha2));
@@ skipping 39 matching lines @@
         kTestAndroidFacetURIGamma);
   }
 
   std::vector<std::string> GetAffiliatedAndroidRealms(
       const PasswordStore::FormDigest& observed_form) {
     expecting_result_callback_ = true;
     match_helper()->GetAffiliatedAndroidRealms(
         observed_form,
         base::Bind(&AffiliatedMatchHelperTest::OnAffiliatedRealmsCallback,
                    base::Unretained(this)));
-    base::RunLoop().RunUntilIdle();
+    RunUntilIdle();
     EXPECT_FALSE(expecting_result_callback_);
     return last_result_realms_;
   }
 
   std::vector<std::string> GetAffiliatedWebRealms(
       const PasswordStore::FormDigest& android_form) {
     expecting_result_callback_ = true;
     match_helper()->GetAffiliatedWebRealms(
         android_form,
         base::Bind(&AffiliatedMatchHelperTest::OnAffiliatedRealmsCallback,
                    base::Unretained(this)));
-    base::RunLoop().RunUntilIdle();
+    RunUntilIdle();
     EXPECT_FALSE(expecting_result_callback_);
     return last_result_realms_;
   }
 
   std::vector<std::unique_ptr<autofill::PasswordForm>>
   InjectAffiliatedWebRealms(
       std::vector<std::unique_ptr<autofill::PasswordForm>> forms) {
     expecting_result_callback_ = true;
     match_helper()->InjectAffiliatedWebRealms(
         std::move(forms),
         base::Bind(&AffiliatedMatchHelperTest::OnFormsCallback,
                    base::Unretained(this)));
-    base::RunLoop().RunUntilIdle();
+    RunUntilIdle();
     EXPECT_FALSE(expecting_result_callback_);
     return std::move(last_result_forms_);
   }
 
   void DestroyMatchHelper() { match_helper_.reset(); }
 
-  base::TestSimpleTaskRunner* waiting_task_runner() {
-    return waiting_task_runner_.get();
-  }
-
   TestPasswordStore* password_store() { return password_store_.get(); }
 
   MockAffiliationService* mock_affiliation_service() {
     return mock_affiliation_service_;
   }
 
   AffiliatedMatchHelper* match_helper() { return match_helper_.get(); }
 
  private:
   void OnAffiliatedRealmsCallback(
@@ skipping 13 matching lines @@
   // testing::Test:
   void SetUp() override {
     std::unique_ptr<MockAffiliationService> service(
         new MockAffiliationService());
     mock_affiliation_service_ = service.get();
 
     password_store_ = new TestPasswordStore;
 
     match_helper_.reset(
         new AffiliatedMatchHelper(password_store_.get(), std::move(service)));
-    match_helper_->SetTaskRunnerUsedForWaitingForTesting(waiting_task_runner_);
   }
 
   void TearDown() override {
     match_helper_.reset();
     password_store_->ShutdownOnUIThread();
     password_store_ = nullptr;
   }
 
-  scoped_refptr<base::TestSimpleTaskRunner> waiting_task_runner_;
   base::MessageLoop message_loop_;
+  base::ScopedMockTimeMessageLoopTaskRunner mock_time_task_runner_;
+
   std::vector<std::string> last_result_realms_;
   std::vector<std::unique_ptr<autofill::PasswordForm>> last_result_forms_;
   bool expecting_result_callback_;
 
   scoped_refptr<TestPasswordStore> password_store_;
   std::unique_ptr<AffiliatedMatchHelper> match_helper_;
 
   // Owned by |match_helper_|.
   MockAffiliationService* mock_affiliation_service_;
 
@@ skipping 148 matching lines @@
       AffiliatedMatchHelper::IsValidAndroidCredential(android_credential));
 }
 
 // Verifies that affiliations for Android applications with pre-existing
 // credentials on start-up are prefetched.
 TEST_F(AffiliatedMatchHelperTest,
        PrefetchAffiliationsForPreexistingAndroidCredentialsOnStartup) {
   AddAndroidAndNonAndroidTestLogins();
 
   match_helper()->Initialize();
-  base::RunLoop().RunUntilIdle();
+  RunUntilIdle();
 
   ExpectPrefetchForAndroidTestLogins();
   ASSERT_NO_FATAL_FAILURE(RunDeferredInitialization());
 }
 
 // Stores credentials for Android applications between Initialize() and
 // DoDeferredInitialization(). Verifies that corresponding affiliation
 // information gets prefetched.
 TEST_F(AffiliatedMatchHelperTest,
        PrefetchAffiliationsForAndroidCredentialsAddedInInitializationDelay) {
   match_helper()->Initialize();
-  base::RunLoop().RunUntilIdle();
+  RunUntilIdle();
 
   AddAndroidAndNonAndroidTestLogins();
 
   ExpectPrefetchForAndroidTestLogins();
   ASSERT_NO_FATAL_FAILURE(RunDeferredInitialization());
 }
 
 // Stores credentials for Android applications after DoDeferredInitialization().
 // Verifies that corresponding affiliation information gets prefetched.
 TEST_F(AffiliatedMatchHelperTest,
@@ skipping 57 matching lines @@
   autofill::PasswordForm android_form(
       GetTestAndroidCredentials(kTestAndroidRealmAlpha3));
   AddLogin(android_form);
 
   // Store two credentials before initialization.
   autofill::PasswordForm android_form2(android_form);
   android_form2.username_value = base::ASCIIToUTF16("JohnDoe2");
   AddLogin(android_form2);
 
   match_helper()->Initialize();
-  base::RunLoop().RunUntilIdle();
+  RunUntilIdle();
 
   // Store one credential between initialization and deferred initialization.
   autofill::PasswordForm android_form3(android_form);
   android_form3.username_value = base::ASCIIToUTF16("JohnDoe3");
   AddLogin(android_form3);
 
   ASSERT_NO_FATAL_FAILURE(RunDeferredInitialization());
 
   // Store one credential after deferred initialization.
   autofill::PasswordForm android_form4(android_form);
   android_form4.username_value = base::ASCIIToUTF16("JohnDoe4");
   AddLogin(android_form4);
 
   for (size_t i = 0; i < 4; ++i) {
     mock_affiliation_service()->ExpectCallToCancelPrefetch(
         kTestAndroidFacetURIAlpha3);
     mock_affiliation_service()->ExpectCallToTrimCacheForFacet(
         kTestAndroidFacetURIAlpha3);
   }
 
   RemoveLogin(android_form);
   RemoveLogin(android_form2);
   RemoveLogin(android_form3);
   RemoveLogin(android_form4);
 }
 
 TEST_F(AffiliatedMatchHelperTest, DestroyBeforeDeferredInitialization) {
   match_helper()->Initialize();
-  base::RunLoop().RunUntilIdle();
+  RunUntilIdle();
   DestroyMatchHelper();
   ASSERT_NO_FATAL_FAILURE(RunDeferredInitialization());
 }
 
 }  // namespace password_manager