Introduce the ThrottleManager

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"
@@ skipping 123 matching lines @@
 
 TEST_F(AsyncDocumentSubresourceFilterTest, ActivationStateIsReported) {
   dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset()));
   auto ruleset_handle = CreateRulesetHandle();
 
   AsyncDocumentSubresourceFilter::InitializationParams params(
       GURL("http://example.com"), ActivationLevel::ENABLED, false);
 
   testing::TestActivationStateCallbackReceiver activation_state;
   auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
-      ruleset_handle.get(), std::move(params), activation_state.GetCallback(),
-      base::OnceClosure());
+      ruleset_handle.get(), std::move(params), activation_state.GetCallback());
 
   RunUntilIdle();
   activation_state.ExpectReceivedOnce(
       ActivationState(ActivationLevel::ENABLED));
 }
 
 TEST_F(AsyncDocumentSubresourceFilterTest, ActivationStateIsComputedCorrectly) {
   dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset()));
   auto ruleset_handle = CreateRulesetHandle();
 
   AsyncDocumentSubresourceFilter::InitializationParams params(
       GURL("http://whitelisted.subframe.com"), ActivationLevel::ENABLED, false);
   params.parent_document_origin = url::Origin(GURL("http://example.com"));
 
   testing::TestActivationStateCallbackReceiver activation_state;
   auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
-      ruleset_handle.get(), std::move(params), activation_state.GetCallback(),
-      base::OnceClosure());
+      ruleset_handle.get(), std::move(params), activation_state.GetCallback());
 
   RunUntilIdle();
 
   ActivationState expected_activation_state(ActivationLevel::ENABLED);
   expected_activation_state.generic_blocking_rules_disabled = true;
   activation_state.ExpectReceivedOnce(expected_activation_state);
 }
 
 TEST_F(AsyncDocumentSubresourceFilterTest, DisabledForCorruptRuleset) {
   testing::TestRuleset::CorruptByFilling(ruleset(), 0, 100, 0xFF);
   dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset()));
 
   auto ruleset_handle = CreateRulesetHandle();
 
   AsyncDocumentSubresourceFilter::InitializationParams params(
       GURL("http://example.com"), ActivationLevel::ENABLED, false);
 
   testing::TestActivationStateCallbackReceiver activation_state;
   auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
-      ruleset_handle.get(), std::move(params), activation_state.GetCallback(),
-      base::OnceClosure());
+      ruleset_handle.get(), std::move(params), activation_state.GetCallback());
 
   RunUntilIdle();
   activation_state.ExpectReceivedOnce(
       ActivationState(ActivationLevel::DISABLED));
 }
 
 TEST_F(AsyncDocumentSubresourceFilterTest, GetLoadPolicyForSubdocument) {
   dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset()));
   auto ruleset_handle = CreateRulesetHandle();
 
   AsyncDocumentSubresourceFilter::InitializationParams params(
       GURL("http://example.com"), ActivationLevel::ENABLED, false);
 
   testing::TestActivationStateCallbackReceiver activation_state;
   auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
-      ruleset_handle.get(), std::move(params), activation_state.GetCallback(),
-      base::OnceClosure());
+      ruleset_handle.get(), std::move(params), activation_state.GetCallback());
 
   LoadPolicyCallbackReceiver load_policy_1;
   LoadPolicyCallbackReceiver load_policy_2;
   filter->GetLoadPolicyForSubdocument(GURL("http://example.com/allowed.html"),
                                       load_policy_1.GetCallback());
   filter->GetLoadPolicyForSubdocument(
       GURL("http://example.com/disallowed.html"), load_policy_2.GetCallback());
 
   RunUntilIdle();
   load_policy_1.ExpectReceivedOnce(LoadPolicy::ALLOW);
   load_policy_2.ExpectReceivedOnce(LoadPolicy::DISALLOW);
 }
 
 TEST_F(AsyncDocumentSubresourceFilterTest, FirstDisallowedLoadIsReported) {
   dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset()));
   auto ruleset_handle = CreateRulesetHandle();
 
   TestCallbackReceiver first_disallowed_load_receiver;
   AsyncDocumentSubresourceFilter::InitializationParams params(
       GURL("http://example.com"), ActivationLevel::ENABLED, false);
 
   testing::TestActivationStateCallbackReceiver activation_state;
   auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
-      ruleset_handle.get(), std::move(params), activation_state.GetCallback(),
+      ruleset_handle.get(), std::move(params), activation_state.GetCallback());
+  filter->set_first_disallowed_load_callback(
       first_disallowed_load_receiver.GetClosure());
 
   LoadPolicyCallbackReceiver load_policy_1;
   filter->GetLoadPolicyForSubdocument(GURL("http://example.com/allowed.html"),
                                       load_policy_1.GetCallback());
   RunUntilIdle();
   load_policy_1.ExpectReceivedOnce(LoadPolicy::ALLOW);
   EXPECT_EQ(0, first_disallowed_load_receiver.callback_count());
 
   LoadPolicyCallbackReceiver load_policy_2;
   filter->GetLoadPolicyForSubdocument(
       GURL("http://example.com/disallowed.html"), load_policy_2.GetCallback());
   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