// 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/activation_state_computing_navigation_throttle.h"

#include <memory>
#include <utility>
#include <vector>

#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/scoped_refptr.h"
#include "base/optional.h"
#include "base/run_loop.h"
#include "base/sequenced_task_runner.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/test_simple_task_runner.h"
#include "base/threading/sequenced_task_runner_handle.h"
#include "components/subresource_filter/content/browser/async_document_subresource_filter.h"
#include "components/subresource_filter/content/browser/async_document_subresource_filter_test_utils.h"
#include "components/subresource_filter/core/common/scoped_timers.h"
#include "components/subresource_filter/core/common/test_ruleset_creator.h"
#include "components/subresource_filter/core/common/test_ruleset_utils.h"
#include "components/subresource_filter/core/mojom/subresource_filter.mojom.h"
#include "components/url_pattern_index/proto/rules.pb.h"
#include "content/public/browser/navigation_handle.h"
#include "content/public/browser/web_contents_observer.h"
#include "content/public/test/navigation_simulator.h"
#include "content/public/test/test_renderer_host.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace subresource_filter {

namespace {

// Histogram name on thread timers. Please, use |ExpectThreadTimers| for
// expectation calls corrections.
constexpr char kActivationCPU[] =
    "SubresourceFilter.DocumentLoad.Activation.CPUDuration";

int ExpectThreadTimers(int expected) {
  return ScopedThreadTimers::IsSupported() ? expected : 0;
}

}  // namespace

namespace proto = url_pattern_index::proto;

// The tests are parameterized by a bool which enables speculative main frame
// activation computation in DRYRUN mode. In practice, this will correspond to
// the kAdTagging feature.
class ActivationStateComputingNavigationThrottleTest
    : public content::RenderViewHostTestHarness,
      public content::WebContentsObserver,
      public ::testing::WithParamInterface<bool> {
 public:
  ActivationStateComputingNavigationThrottleTest()
      : simple_task_runner_(base::MakeRefCounted<base::TestSimpleTaskRunner>()),
        dryrun_speculation_(GetParam()) {}
  ~ActivationStateComputingNavigationThrottleTest() override {}

  void SetUp() override {
    content::RenderViewHostTestHarness::SetUp();
    NavigateAndCommit(GURL("https://example.first"));
    InitializeRuleset();
    Observe(RenderViewHostTestHarness::web_contents());
  }

  void TearDown() override {
    ruleset_handle_.reset();
    dealer_handle_.reset();

    // The various ruleset classes post tasks to delete their blocking task
    // runners. Make sure that happens now to avoid test-only leaks.
    base::RunLoop().RunUntilIdle();
    simple_task_runner()->RunUntilIdle();
    content::RenderViewHostTestHarness::TearDown();
  }

  void InitializeRuleset() {
    std::vector<proto::UrlRule> rules;
    rules.push_back(testing::CreateWhitelistRuleForDocument(
        "whitelisted.com", proto::ACTIVATION_TYPE_DOCUMENT,
        {"allow-child-to-be-whitelisted.com",
         "whitelisted-generic-with-disabled-child.com"}));

    rules.push_back(testing::CreateWhitelistRuleForDocument(
        "whitelisted-generic.com", proto::ACTIVATION_TYPE_GENERICBLOCK,
        {"allow-child-to-be-whitelisted.com"}));

    rules.push_back(testing::CreateWhitelistRuleForDocument(
        "whitelisted-generic-with-disabled-child.com",
        proto::ACTIVATION_TYPE_GENERICBLOCK,
        {"allow-child-to-be-whitelisted.com"}));

    rules.push_back(testing::CreateWhitelistRuleForDocument(
        "whitelisted-always.com", proto::ACTIVATION_TYPE_DOCUMENT));

    ASSERT_NO_FATAL_FAILURE(test_ruleset_creator_.CreateRulesetWithRules(
        rules, &test_ruleset_pair_));

    // Make the blocking task runner run on the current task runner for the
    // tests, to ensure that the NavigationSimulator properly runs all necessary
    // tasks while waiting for throttle checks to finish.
    InitializeRulesetHandles(base::SequencedTaskRunnerHandle::Get());
  }

  void NavigateAndCommitMainFrameWithPageActivationState(
      const GURL& document_url,
      const mojom::ActivationLevel& level) {
    mojom::ActivationState state;
    state.activation_level = level;
    CreateTestNavigationForMainFrame(document_url);
    SimulateStartAndExpectToProceed();

    NotifyPageActivation(state);
    SimulateCommitAndExpectToProceed();
  }

  void CreateTestNavigationForMainFrame(const GURL& first_url) {
    navigation_simulator_ =
        content::NavigationSimulator::CreateRendererInitiated(first_url,
                                                              main_rfh());
  }

  void CreateSubframeAndInitTestNavigation(
      const GURL& first_url,
      content::RenderFrameHost* parent,
      const mojom::ActivationState& parent_activation_state) {
    ASSERT_TRUE(parent);
    parent_activation_state_ = parent_activation_state;
    content::RenderFrameHost* navigating_subframe =
        content::RenderFrameHostTester::For(parent)->AppendChild("subframe");
    navigation_simulator_ =
        content::NavigationSimulator::CreateRendererInitiated(
            first_url, navigating_subframe);
  }

  void SimulateStartAndExpectToProceed() {
    ASSERT_TRUE(navigation_simulator_);
    navigation_simulator_->Start();
    EXPECT_EQ(content::NavigationThrottle::PROCEED,
              navigation_simulator_->GetLastThrottleCheckResult());
  }

  void SimulateRedirectAndExpectToProceed(const GURL& new_url) {
    navigation_simulator_->Redirect(new_url);
    EXPECT_EQ(content::NavigationThrottle::PROCEED,
              navigation_simulator_->GetLastThrottleCheckResult());
  }

  void SimulateCommitAndExpectToProceed() {
    navigation_simulator_->Commit();
    EXPECT_EQ(content::NavigationThrottle::PROCEED,
              navigation_simulator_->GetLastThrottleCheckResult());
  }

  void InitializeRulesetHandles(
      scoped_refptr<base::SequencedTaskRunner> ruleset_task_runner) {
    dealer_handle_ = std::make_unique<VerifiedRulesetDealer::Handle>(
        std::move(ruleset_task_runner));
    dealer_handle_->TryOpenAndSetRulesetFile(test_ruleset_pair_.indexed.path,
                                             /*expected_checksum=*/0,
                                             base::DoNothing());
    ruleset_handle_ =
        std::make_unique<VerifiedRuleset::Handle>(dealer_handle_.get());
  }

  void NotifyPageActivation(mojom::ActivationState state) {
    test_throttle_->NotifyPageActivationWithRuleset(ruleset_handle_.get(),
                                                    state);
  }

  mojom::ActivationState last_activation_state() {
    EXPECT_TRUE(last_activation_state_.has_value());
    return last_activation_state_.value_or(mojom::ActivationState());
  }

  content::RenderFrameHost* last_committed_frame_host() {
    return last_committed_frame_host_;
  }

  scoped_refptr<base::TestSimpleTaskRunner> simple_task_runner() {
    return simple_task_runner_;
  }

  void set_parent_activation_state(const mojom::ActivationState& state) {
    parent_activation_state_ = state;
  }

 protected:
  // content::WebContentsObserver:
  void DidStartNavigation(
      content::NavigationHandle* navigation_handle) override {
    std::unique_ptr<ActivationStateComputingNavigationThrottle> throttle =
        navigation_handle->IsInMainFrame()
            ? ActivationStateComputingNavigationThrottle::CreateForMainFrame(
                  navigation_handle)
            : ActivationStateComputingNavigationThrottle::CreateForSubframe(
                  navigation_handle, ruleset_handle_.get(),
                  parent_activation_state_.value());
    if (navigation_handle->IsInMainFrame() && dryrun_speculation_) {
      mojom::ActivationState dryrun_state;
      dryrun_state.activation_level = mojom::ActivationLevel::kDryRun;
      throttle->NotifyPageActivationWithRuleset(ruleset_handle_.get(),
                                                dryrun_state);
    }
    test_throttle_ = throttle.get();
    navigation_handle->RegisterThrottleForTesting(std::move(throttle));
  }

  void ReadyToCommitNavigation(
      content::NavigationHandle* navigation_handle) override {
    if (!test_throttle_)
      return;
    ASSERT_EQ(navigation_handle, test_throttle_->navigation_handle());
    if (test_throttle_->filter())
      test_throttle_->WillSendActivationToRenderer();

    if (auto filter = test_throttle_->ReleaseFilter()) {
      EXPECT_NE(mojom::ActivationLevel::kDisabled,
                filter->activation_state().activation_level);
      last_activation_state_ = filter->activation_state();
    } else {
      last_activation_state_ = mojom::ActivationState();
    }
  }

  void DidFinishNavigation(
      content::NavigationHandle* navigation_handle) override {
    if (!test_throttle_)
      return;
    last_committed_frame_host_ = navigation_handle->GetRenderFrameHost();
    test_throttle_ = nullptr;
  }

  bool dryrun_speculation() const { return dryrun_speculation_; }

 private:
  testing::TestRulesetCreator test_ruleset_creator_;
  testing::TestRulesetPair test_ruleset_pair_;

  std::unique_ptr<VerifiedRulesetDealer::Handle> dealer_handle_;
  std::unique_ptr<VerifiedRuleset::Handle> ruleset_handle_;

  std::unique_ptr<content::NavigationSimulator> navigation_simulator_;

  scoped_refptr<base::TestSimpleTaskRunner> simple_task_runner_;

  // Owned by the current navigation.
  ActivationStateComputingNavigationThrottle* test_throttle_;
  base::Optional<mojom::ActivationState> last_activation_state_;
  base::Optional<mojom::ActivationState> parent_activation_state_;

  // Needed for potential cross process navigations which swap hosts.
  content::RenderFrameHost* last_committed_frame_host_ = nullptr;

  bool dryrun_speculation_;

  DISALLOW_COPY_AND_ASSIGN(ActivationStateComputingNavigationThrottleTest);
};

typedef ActivationStateComputingNavigationThrottleTest
    ActivationStateComputingThrottleMainFrameTest;
typedef ActivationStateComputingNavigationThrottleTest
    ActivationStateComputingThrottleSubFrameTest;

TEST_P(ActivationStateComputingThrottleMainFrameTest, Activate) {
  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://example.test/"), mojom::ActivationLevel::kEnabled);
  mojom::ActivationState state = last_activation_state();
  EXPECT_EQ(mojom::ActivationLevel::kEnabled, state.activation_level);
  EXPECT_FALSE(state.filtering_disabled_for_document);
}

TEST_P(ActivationStateComputingThrottleMainFrameTest,
       NoPageActivationNotification_NoActivation) {
  CreateTestNavigationForMainFrame(GURL("http://example.test/"));
  SimulateStartAndExpectToProceed();
  SimulateRedirectAndExpectToProceed(GURL("http://example.test/?v=1"));

  // Never send NotifyPageActivation.
  SimulateCommitAndExpectToProceed();

  mojom::ActivationState state = last_activation_state();
  EXPECT_EQ(mojom::ActivationLevel::kDisabled, state.activation_level);
}

TEST_P(ActivationStateComputingThrottleMainFrameTest,
       WhitelistDoesNotApply_CausesActivation) {
  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://allow-child-to-be-whitelisted.com/"),
      mojom::ActivationLevel::kEnabled);

  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://whitelisted.com/"), mojom::ActivationLevel::kEnabled);

  mojom::ActivationState state = last_activation_state();
  EXPECT_FALSE(state.filtering_disabled_for_document);
  EXPECT_FALSE(state.generic_blocking_rules_disabled);
  EXPECT_EQ(mojom::ActivationLevel::kEnabled, state.activation_level);
}

TEST_P(ActivationStateComputingThrottleMainFrameTest,
       Whitelisted_DisablesFiltering) {
  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://whitelisted-always.com/"), mojom::ActivationLevel::kEnabled);

  mojom::ActivationState state = last_activation_state();
  EXPECT_TRUE(state.filtering_disabled_for_document);
  EXPECT_FALSE(state.generic_blocking_rules_disabled);
  EXPECT_EQ(mojom::ActivationLevel::kEnabled, state.activation_level);
}

TEST_P(ActivationStateComputingThrottleSubFrameTest, Activate) {
  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://example.test/"), mojom::ActivationLevel::kEnabled);

  CreateSubframeAndInitTestNavigation(GURL("http://example.child/"),
                                      last_committed_frame_host(),
                                      last_activation_state());
  SimulateStartAndExpectToProceed();
  SimulateRedirectAndExpectToProceed(GURL("http://example.child/?v=1"));
  SimulateCommitAndExpectToProceed();

  mojom::ActivationState state = last_activation_state();
  EXPECT_EQ(mojom::ActivationLevel::kEnabled, state.activation_level);
  EXPECT_FALSE(state.filtering_disabled_for_document);
  EXPECT_FALSE(state.generic_blocking_rules_disabled);
}

TEST_P(ActivationStateComputingThrottleSubFrameTest,
       WhitelistDoesNotApply_CausesActivation) {
  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://disallows-child-to-be-whitelisted.com/"),
      mojom::ActivationLevel::kEnabled);

  CreateSubframeAndInitTestNavigation(GURL("http://whitelisted.com/"),
                                      last_committed_frame_host(),
                                      last_activation_state());
  SimulateStartAndExpectToProceed();
  SimulateCommitAndExpectToProceed();

  mojom::ActivationState state = last_activation_state();
  EXPECT_EQ(mojom::ActivationLevel::kEnabled, state.activation_level);
  EXPECT_FALSE(state.filtering_disabled_for_document);
  EXPECT_FALSE(state.generic_blocking_rules_disabled);
}

TEST_P(ActivationStateComputingThrottleSubFrameTest,
       Whitelisted_DisableDocumentFiltering) {
  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://allow-child-to-be-whitelisted.com/"),
      mojom::ActivationLevel::kEnabled);

  CreateSubframeAndInitTestNavigation(GURL("http://whitelisted.com/"),
                                      last_committed_frame_host(),
                                      last_activation_state());
  SimulateStartAndExpectToProceed();
  SimulateCommitAndExpectToProceed();

  mojom::ActivationState state = last_activation_state();
  EXPECT_TRUE(state.filtering_disabled_for_document);
  EXPECT_FALSE(state.generic_blocking_rules_disabled);
  EXPECT_EQ(mojom::ActivationLevel::kEnabled, state.activation_level);
}

TEST_P(ActivationStateComputingThrottleSubFrameTest,
       Whitelisted_DisablesGenericRules) {
  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://allow-child-to-be-whitelisted.com/"),
      mojom::ActivationLevel::kEnabled);

  CreateSubframeAndInitTestNavigation(GURL("http://whitelisted-generic.com/"),
                                      last_committed_frame_host(),
                                      last_activation_state());
  SimulateStartAndExpectToProceed();
  SimulateCommitAndExpectToProceed();

  mojom::ActivationState state = last_activation_state();
  EXPECT_FALSE(state.filtering_disabled_for_document);
  EXPECT_TRUE(state.generic_blocking_rules_disabled);
  EXPECT_EQ(mojom::ActivationLevel::kEnabled, state.activation_level);
}

TEST_P(ActivationStateComputingThrottleSubFrameTest, DryRunIsPropagated) {
  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://example.test/"), mojom::ActivationLevel::kDryRun);
  EXPECT_EQ(mojom::ActivationLevel::kDryRun,
            last_activation_state().activation_level);

  CreateSubframeAndInitTestNavigation(GURL("http://example.child/"),
                                      last_committed_frame_host(),
                                      last_activation_state());
  SimulateStartAndExpectToProceed();
  SimulateRedirectAndExpectToProceed(GURL("http://example.child/?v=1"));
  SimulateCommitAndExpectToProceed();

  mojom::ActivationState state = last_activation_state();
  EXPECT_EQ(mojom::ActivationLevel::kDryRun, state.activation_level);
  EXPECT_FALSE(state.filtering_disabled_for_document);
  EXPECT_FALSE(state.generic_blocking_rules_disabled);
}

TEST_P(ActivationStateComputingThrottleSubFrameTest,
       DryRunWithLoggingIsPropagated) {
  mojom::ActivationState page_state;
  page_state.activation_level = mojom::ActivationLevel::kDryRun;
  page_state.enable_logging = true;

  CreateTestNavigationForMainFrame(GURL("http://example.test/"));
  SimulateStartAndExpectToProceed();

  NotifyPageActivation(page_state);
  SimulateCommitAndExpectToProceed();

  EXPECT_EQ(mojom::ActivationLevel::kDryRun,
            last_activation_state().activation_level);

  CreateSubframeAndInitTestNavigation(GURL("http://example.child/"),
                                      last_committed_frame_host(),
                                      last_activation_state());
  SimulateStartAndExpectToProceed();
  SimulateRedirectAndExpectToProceed(GURL("http://example.child/?v=1"));
  SimulateCommitAndExpectToProceed();

  mojom::ActivationState state = last_activation_state();
  EXPECT_EQ(mojom::ActivationLevel::kDryRun, state.activation_level);
  EXPECT_TRUE(state.enable_logging);
  EXPECT_FALSE(state.filtering_disabled_for_document);
  EXPECT_FALSE(state.generic_blocking_rules_disabled);
}

TEST_P(ActivationStateComputingThrottleSubFrameTest, DisabledStatePropagated) {
  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://allow-child-to-be-whitelisted.com/"),
      mojom::ActivationLevel::kEnabled);

  CreateSubframeAndInitTestNavigation(GURL("http://whitelisted.com"),
                                      last_committed_frame_host(),
                                      last_activation_state());
  SimulateStartAndExpectToProceed();
  SimulateCommitAndExpectToProceed();

  CreateSubframeAndInitTestNavigation(GURL("http://example.test/"),
                                      last_committed_frame_host(),
                                      last_activation_state());
  SimulateStartAndExpectToProceed();
  SimulateCommitAndExpectToProceed();

  mojom::ActivationState state = last_activation_state();
  EXPECT_EQ(mojom::ActivationLevel::kEnabled, state.activation_level);
  EXPECT_TRUE(state.filtering_disabled_for_document);
  EXPECT_FALSE(state.generic_blocking_rules_disabled);
}

TEST_P(ActivationStateComputingThrottleSubFrameTest, DisabledStatePropagated2) {
  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://allow-child-to-be-whitelisted.com/"),
      mojom::ActivationLevel::kEnabled);

  CreateSubframeAndInitTestNavigation(
      GURL("http://whitelisted-generic-with-disabled-child.com/"),
      last_committed_frame_host(), last_activation_state());
  SimulateStartAndExpectToProceed();
  SimulateCommitAndExpectToProceed();

  mojom::ActivationState state = last_activation_state();
  EXPECT_FALSE(state.filtering_disabled_for_document);
  EXPECT_TRUE(state.generic_blocking_rules_disabled);

  CreateSubframeAndInitTestNavigation(GURL("http://whitelisted.com/"),
                                      last_committed_frame_host(),
                                      last_activation_state());
  SimulateStartAndExpectToProceed();
  SimulateCommitAndExpectToProceed();

  state = last_activation_state();
  EXPECT_EQ(mojom::ActivationLevel::kEnabled, state.activation_level);
  EXPECT_TRUE(state.filtering_disabled_for_document);
  EXPECT_TRUE(state.generic_blocking_rules_disabled);
}

TEST_P(ActivationStateComputingThrottleSubFrameTest, DelayMetrics) {
  base::HistogramTester histogram_tester;
  NavigateAndCommitMainFrameWithPageActivationState(
      GURL("http://example.test/"), mojom::ActivationLevel::kEnabled);
  mojom::ActivationState state = last_activation_state();
  EXPECT_EQ(mojom::ActivationLevel::kEnabled, state.activation_level);
  EXPECT_FALSE(state.filtering_disabled_for_document);

  const char kActivationDelay[] =
      "SubresourceFilter.DocumentLoad.ActivationComputingDelay";
  const char kActivationDelayMainFrame[] =
      "SubresourceFilter.DocumentLoad.ActivationComputingDelay.MainFrame";
  histogram_tester.ExpectTotalCount(kActivationDelay, 1);
  histogram_tester.ExpectTotalCount(kActivationDelayMainFrame, 1);

  // Subframe activation should not log main frame metrics.
  CreateSubframeAndInitTestNavigation(GURL("http://example.test/"),
                                      last_committed_frame_host(),
                                      last_activation_state());
  SimulateStartAndExpectToProceed();
  SimulateCommitAndExpectToProceed();
  histogram_tester.ExpectTotalCount(kActivationDelay, 2);
  histogram_tester.ExpectTotalCount(kActivationDelayMainFrame, 1);

  // No page activation should imply no delay.
  CreateTestNavigationForMainFrame(GURL("http://example.test2/"));
  SimulateStartAndExpectToProceed();
  SimulateCommitAndExpectToProceed();

  state = last_activation_state();
  EXPECT_EQ(dryrun_speculation() ? mojom::ActivationLevel::kDryRun
                                 : mojom::ActivationLevel::kDisabled,
            state.activation_level);
  int extra_activation = dryrun_speculation() ? 1 : 0;
  histogram_tester.ExpectTotalCount(kActivationDelay, 2 + extra_activation);
  histogram_tester.ExpectTotalCount(kActivationDelayMainFrame,
                                    1 + extra_activation);
}

TEST_P(ActivationStateComputingThrottleSubFrameTest, Speculation) {
  // Use the activation performance metric as a proxy for how many times
  // activation computation occurred.
  base::HistogramTester main_histogram_tester;

  // Main frames don't do speculative lookups, a navigation commit should only
  // trigger a single ruleset lookup.
  CreateTestNavigationForMainFrame(GURL("http://example.test/"));
  SimulateStartAndExpectToProceed();
  base::RunLoop().RunUntilIdle();
  int main_frame_checks = dryrun_speculation() ? 1 : 0;
  main_histogram_tester.ExpectTotalCount(kActivationCPU,
                                         ExpectThreadTimers(main_frame_checks));

  SimulateRedirectAndExpectToProceed(GURL("http://example.test2/"));
  base::RunLoop().RunUntilIdle();
  main_frame_checks += dryrun_speculation() ? 1 : 0;
  main_histogram_tester.ExpectTotalCount(kActivationCPU,
                                         ExpectThreadTimers(main_frame_checks));

  mojom::ActivationState state;
  state.activation_level = mojom::ActivationLevel::kEnabled;
  NotifyPageActivation(state);
  SimulateCommitAndExpectToProceed();
  main_frame_checks += dryrun_speculation() ? 0 : 1;
  main_histogram_tester.ExpectTotalCount(kActivationCPU,
                                         ExpectThreadTimers(main_frame_checks));

  base::HistogramTester sub_histogram_tester;
  CreateSubframeAndInitTestNavigation(GURL("http://example.test/"),
                                      last_committed_frame_host(),
                                      last_activation_state());
  // For subframes, do a ruleset lookup at the start and every redirect.
  SimulateStartAndExpectToProceed();
  base::RunLoop().RunUntilIdle();
  sub_histogram_tester.ExpectTotalCount(kActivationCPU, ExpectThreadTimers(1));

  SimulateRedirectAndExpectToProceed(GURL("http://example.test2/"));
  base::RunLoop().RunUntilIdle();
  sub_histogram_tester.ExpectTotalCount(kActivationCPU, ExpectThreadTimers(2));

  // No ruleset lookup required at commit because we've already checked the
  // latest URL.
  SimulateCommitAndExpectToProceed();
  sub_histogram_tester.ExpectTotalCount(kActivationCPU, ExpectThreadTimers(2));
}

TEST_P(ActivationStateComputingThrottleSubFrameTest, SpeculationWithDelay) {
  InitializeRulesetHandles(simple_task_runner());

  // Use the activation performance metric as a proxy for how many times
  // activation computation occurred.
  base::HistogramTester main_histogram_tester;

  // Main frames will do speculative lookup only in some cases.
  auto simulator = content::NavigationSimulator::CreateRendererInitiated(
      GURL("http://example.test/"), main_rfh());
  simulator->SetAutoAdvance(false);

  simulator->Start();
  EXPECT_FALSE(simulator->IsDeferred());
  main_histogram_tester.ExpectTotalCount(kActivationCPU, 0);

  simulator->Redirect(GURL("http://example.test2/"));
  EXPECT_FALSE(simulator->IsDeferred());
  main_histogram_tester.ExpectTotalCount(kActivationCPU, 0);

  mojom::ActivationState state;
  state.activation_level = mojom::ActivationLevel::kEnabled;
  NotifyPageActivation(state);

  simulator->ReadyToCommit();
  EXPECT_TRUE(simulator->IsDeferred());
  EXPECT_LT(0u, simple_task_runner()->NumPendingTasks());
  simple_task_runner()->RunPendingTasks();
  // If speculation was enabled for this test, will do a lookup at start and
  // redirect.
  main_histogram_tester.ExpectTotalCount(
      kActivationCPU, ExpectThreadTimers(dryrun_speculation() ? 2 : 1));
  simulator->Wait();
  EXPECT_FALSE(simulator->IsDeferred());
  EXPECT_EQ(content::NavigationThrottle::PROCEED,
            simulator->GetLastThrottleCheckResult());
  simulator->Commit();

  base::HistogramTester sub_histogram_tester;
  auto subframe_simulator =
      content::NavigationSimulator::CreateRendererInitiated(
          GURL("http://example.test"),
          content::RenderFrameHostTester::For(main_rfh())
              ->AppendChild("subframe"));
  subframe_simulator->SetAutoAdvance(false);
  set_parent_activation_state(last_activation_state());

  // Simulate slow ruleset checks for the subframe, these should not delay the
  // navigation until commit time.
  subframe_simulator->Start();
  EXPECT_FALSE(subframe_simulator->IsDeferred());
  sub_histogram_tester.ExpectTotalCount(kActivationCPU, 0);

  // Calling redirect should ensure that the throttle does not receive the
  // results of the check, but the task to actually perform the check will still
  // happen.
  subframe_simulator->Redirect(GURL("http://example.test2/"));
  EXPECT_FALSE(subframe_simulator->IsDeferred());
  sub_histogram_tester.ExpectTotalCount(kActivationCPU, 0);

  // Finish the checks dispatched in the start and redirect phase when the
  // navigation is ready to commit.
  subframe_simulator->ReadyToCommit();
  EXPECT_TRUE(subframe_simulator->IsDeferred());
  EXPECT_LT(0u, simple_task_runner()->NumPendingTasks());
  simple_task_runner()->RunPendingTasks();
  subframe_simulator->Wait();
  EXPECT_FALSE(subframe_simulator->IsDeferred());
  EXPECT_EQ(content::NavigationThrottle::PROCEED,
            simulator->GetLastThrottleCheckResult());
  sub_histogram_tester.ExpectTotalCount(kActivationCPU, ExpectThreadTimers(2));
}

INSTANTIATE_TEST_CASE_P(,
                        ActivationStateComputingNavigationThrottleTest,
                        ::testing::Values(true, false));
INSTANTIATE_TEST_CASE_P(,
                        ActivationStateComputingThrottleSubFrameTest,
                        ::testing::Values(true, false));

}  // namespace subresource_filter