Introduce ThreadTaskRunnerHandle::OverrideForTesting and TestMockTimeTaskRunner::ScopedContext.

components/subresource_filter/content/browser/async_document_subresource_filter_unittest.cc

 // Copyright 2017 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/subresource_filter/content/browser/async_document_subresource_filter.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "components/subresource_filter/core/common/proto/rules.pb.h"
 #include "components/subresource_filter/core/common/test_ruleset_creator.h"
 #include "components/subresource_filter/core/common/test_ruleset_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace subresource_filter {
 
 class AsyncDocumentSubresourceFilterTest : public ::testing::Test {
  public:
-  AsyncDocumentSubresourceFilterTest()
-      : reply_task_runner_(new base::TestSimpleTaskRunner),
-        reply_task_runner_handle_(reply_task_runner_),
-        blocking_task_runner_(new base::TestSimpleTaskRunner) {}
+  AsyncDocumentSubresourceFilterTest() = default;
 
  protected:
   void SetUp() override {
     std::vector<proto::UrlRule> rules;
     rules.push_back(testing::CreateWhitelistRuleForDocument(
         "whitelisted.subframe.com", proto::ACTIVATION_TYPE_GENERICBLOCK,
         {"example.com"}));
     rules.push_back(testing::CreateSuffixRule("disallowed.html"));
 
     ASSERT_NO_FATAL_FAILURE(test_ruleset_creator_.CreateRulesetWithRules(
         rules, &test_ruleset_pair_));
 
     dealer_handle_.reset(
         new VerifiedRulesetDealer::Handle(blocking_task_runner_));
   }
 
   void TearDown() override {
     dealer_handle_.reset(nullptr);
     RunUntilIdle();
   }
 
   const testing::TestRuleset& ruleset() const {
     return test_ruleset_pair_.indexed;
   }
 
   void RunUntilIdle() {
-    while (blocking_task_runner_->HasPendingTask() ||
-           reply_task_runner_->HasPendingTask()) {
+    base::RunLoop().RunUntilIdle();
+    while (blocking_task_runner_->HasPendingTask()) {
       blocking_task_runner_->RunUntilIdle();
-      reply_task_runner_->RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
     }
   }
 
   VerifiedRulesetDealer::Handle* dealer_handle() {
     return dealer_handle_.get();
   }
 
   std::unique_ptr<VerifiedRuleset::Handle> CreateRulesetHandle() {
     return base::MakeUnique<VerifiedRuleset::Handle>(dealer_handle());
   }
 
  private:
   testing::TestRulesetCreator test_ruleset_creator_;
   testing::TestRulesetPair test_ruleset_pair_;
 
   // Note: ADSF assumes a task runner is associated with the current thread.
-  scoped_refptr<base::TestSimpleTaskRunner> reply_task_runner_;
-  base::SequencedTaskRunnerHandle reply_task_runner_handle_;
-  scoped_refptr<base::TestSimpleTaskRunner> blocking_task_runner_;
+  // Instantiate a MessageLoop on the current thread and use RunLoop to handle
+  // the replies ADSF tasks generate.
+  base::MessageLoop message_loop_;
+  scoped_refptr<base::TestSimpleTaskRunner> blocking_task_runner_ =
+      new base::TestSimpleTaskRunner;
 
   std::unique_ptr<VerifiedRulesetDealer::Handle> dealer_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncDocumentSubresourceFilterTest);
 };
 
 namespace {
 
 class TestActivationStateCallbackReceiver {
  public:
@@ skipping 170 matching lines @@
   RunUntilIdle();
   load_policy_2.ExpectReceivedOnce(LoadPolicy::DISALLOW);
   EXPECT_EQ(0, first_disallowed_load_receiver.callback_count());
 
   filter->ReportDisallowedLoad();
   EXPECT_EQ(1, first_disallowed_load_receiver.callback_count());
   RunUntilIdle();
 }
 
 }  // namespace subresource_filter