OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "components/subresource_filter/content/browser/async_document_subresour
ce_filter.h" |
| 6 |
| 7 #include <vector> |
| 8 |
| 9 #include "base/bind.h" |
| 10 #include "base/memory/ptr_util.h" |
| 11 #include "base/test/test_simple_task_runner.h" |
| 12 #include "base/threading/sequenced_task_runner_handle.h" |
| 13 #include "components/subresource_filter/core/common/proto/rules.pb.h" |
| 14 #include "components/subresource_filter/core/common/test_ruleset_creator.h" |
| 15 #include "components/subresource_filter/core/common/test_ruleset_utils.h" |
| 16 #include "testing/gtest/include/gtest/gtest.h" |
| 17 |
| 18 namespace subresource_filter { |
| 19 |
| 20 class AsyncDocumentSubresourceFilterTest : public ::testing::Test { |
| 21 public: |
| 22 AsyncDocumentSubresourceFilterTest() |
| 23 : blocking_task_runner_(new base::TestSimpleTaskRunner), |
| 24 reply_task_runner_(new base::TestSimpleTaskRunner), |
| 25 reply_task_runner_handle_(reply_task_runner_) {} |
| 26 |
| 27 protected: |
| 28 void SetUp() override { |
| 29 std::vector<proto::UrlRule> rules; |
| 30 rules.push_back(testing::CreateWhitelistRuleForDocument( |
| 31 "child2.com", proto::ACTIVATION_TYPE_GENERICBLOCK, |
| 32 {"parent1.com", "parent2.com"})); |
| 33 rules.push_back(testing::CreateSuffixRule("block-this.html")); |
| 34 |
| 35 ASSERT_NO_FATAL_FAILURE(test_ruleset_creator_.CreateRulesetWithRules( |
| 36 rules, &test_ruleset_pair_)); |
| 37 |
| 38 dealer_handle_.reset( |
| 39 new VerifiedRulesetDealer::Handle(blocking_task_runner_)); |
| 40 } |
| 41 |
| 42 void TearDown() override { |
| 43 dealer_handle_.reset(nullptr); |
| 44 RunUntilIdle(); |
| 45 } |
| 46 |
| 47 const testing::TestRuleset& ruleset() const { |
| 48 return test_ruleset_pair_.indexed; |
| 49 } |
| 50 |
| 51 void RunUntilIdle() { |
| 52 while (blocking_task_runner_->HasPendingTask() || |
| 53 reply_task_runner_->HasPendingTask()) { |
| 54 blocking_task_runner_->RunUntilIdle(); |
| 55 reply_task_runner_->RunUntilIdle(); |
| 56 } |
| 57 } |
| 58 |
| 59 VerifiedRulesetDealer::Handle* dealer_handle() { |
| 60 return dealer_handle_.get(); |
| 61 } |
| 62 |
| 63 std::unique_ptr<VerifiedRuleset::Handle> CreateRulesetHandle() { |
| 64 return std::unique_ptr<VerifiedRuleset::Handle>( |
| 65 new VerifiedRuleset::Handle(dealer_handle())); |
| 66 } |
| 67 |
| 68 private: |
| 69 scoped_refptr<base::TestSimpleTaskRunner> blocking_task_runner_; |
| 70 scoped_refptr<base::TestSimpleTaskRunner> reply_task_runner_; |
| 71 // Note: ADSF assumes a task runner is associated with the current thread. |
| 72 base::SequencedTaskRunnerHandle reply_task_runner_handle_; |
| 73 |
| 74 testing::TestRulesetCreator test_ruleset_creator_; |
| 75 testing::TestRulesetPair test_ruleset_pair_; |
| 76 |
| 77 std::unique_ptr<VerifiedRulesetDealer::Handle> dealer_handle_; |
| 78 |
| 79 DISALLOW_COPY_AND_ASSIGN(AsyncDocumentSubresourceFilterTest); |
| 80 }; |
| 81 |
| 82 namespace { |
| 83 |
| 84 class TestActivationStateCallbackReceiver { |
| 85 public: |
| 86 TestActivationStateCallbackReceiver() = default; |
| 87 |
| 88 base::Callback<void(ActivationState)> callback() { |
| 89 return base::Bind(&TestActivationStateCallbackReceiver::Callback, |
| 90 base::Unretained(this)); |
| 91 } |
| 92 void Expect(ActivationState expected_state) const { |
| 93 ASSERT_EQ(1, callback_count_); |
| 94 EXPECT_EQ(expected_state, activation_state_); |
| 95 } |
| 96 |
| 97 private: |
| 98 void Callback(ActivationState activation_state) { |
| 99 ++callback_count_; |
| 100 activation_state_ = activation_state; |
| 101 } |
| 102 |
| 103 ActivationState activation_state_; |
| 104 int callback_count_ = 0; |
| 105 |
| 106 DISALLOW_COPY_AND_ASSIGN(TestActivationStateCallbackReceiver); |
| 107 }; |
| 108 |
| 109 class TestCallbackReceiver { |
| 110 public: |
| 111 TestCallbackReceiver() = default; |
| 112 |
| 113 base::Closure closure() { |
| 114 return base::Bind(&TestCallbackReceiver::Callback, base::Unretained(this)); |
| 115 } |
| 116 int callback_count() const { return callback_count_; } |
| 117 |
| 118 private: |
| 119 void Callback() { ++callback_count_; } |
| 120 |
| 121 int callback_count_ = 0; |
| 122 |
| 123 DISALLOW_COPY_AND_ASSIGN(TestCallbackReceiver); |
| 124 }; |
| 125 |
| 126 class LoadPolicyCallbackReceiver { |
| 127 public: |
| 128 LoadPolicyCallbackReceiver() = default; |
| 129 |
| 130 AsyncDocumentSubresourceFilter::LoadPolicyCallback callback() { |
| 131 return base::Bind(&LoadPolicyCallbackReceiver::Callback, |
| 132 base::Unretained(this)); |
| 133 } |
| 134 void Expect(AsyncDocumentSubresourceFilter::LoadPolicy load_policy) const { |
| 135 ASSERT_EQ(1, callback_count_); |
| 136 EXPECT_EQ(load_policy, load_policy_); |
| 137 } |
| 138 |
| 139 private: |
| 140 void Callback(AsyncDocumentSubresourceFilter::LoadPolicy load_policy) { |
| 141 ++callback_count_; |
| 142 load_policy_ = load_policy; |
| 143 } |
| 144 |
| 145 int callback_count_ = 0; |
| 146 AsyncDocumentSubresourceFilter::LoadPolicy load_policy_; |
| 147 |
| 148 DISALLOW_COPY_AND_ASSIGN(LoadPolicyCallbackReceiver); |
| 149 }; |
| 150 |
| 151 } // namespace |
| 152 |
| 153 TEST_F(AsyncDocumentSubresourceFilterTest, ActivationStateIsReported) { |
| 154 dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset())); |
| 155 auto ruleset_handle = CreateRulesetHandle(); |
| 156 |
| 157 AsyncDocumentSubresourceFilter::InitializationParams params( |
| 158 GURL("http://example.com")); |
| 159 |
| 160 TestActivationStateCallbackReceiver activation_state; |
| 161 auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>( |
| 162 ruleset_handle.get(), std::move(params), activation_state.callback(), |
| 163 base::OnceClosure()); |
| 164 |
| 165 RunUntilIdle(); |
| 166 activation_state.Expect(ActivationState(ActivationLevel::ENABLED)); |
| 167 } |
| 168 |
| 169 TEST_F(AsyncDocumentSubresourceFilterTest, ActivationStateIsComputedCorrectly) { |
| 170 dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset())); |
| 171 auto ruleset_handle = CreateRulesetHandle(); |
| 172 |
| 173 AsyncDocumentSubresourceFilter::InitializationParams params( |
| 174 GURL("http://child2.com")); |
| 175 params.parent_document_origin = url::Origin(GURL("http://parent2.com")); |
| 176 |
| 177 TestActivationStateCallbackReceiver activation_state; |
| 178 auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>( |
| 179 ruleset_handle.get(), std::move(params), activation_state.callback(), |
| 180 base::OnceClosure()); |
| 181 |
| 182 RunUntilIdle(); |
| 183 |
| 184 ActivationState expected_activation_state(ActivationLevel::ENABLED); |
| 185 expected_activation_state.generic_blocking_rules_disabled = true; |
| 186 activation_state.Expect(expected_activation_state); |
| 187 } |
| 188 |
| 189 TEST_F(AsyncDocumentSubresourceFilterTest, DisabledForCorruptRuleset) { |
| 190 testing::TestRuleset::CorruptByFilling(ruleset(), 0, 100, 0xFF); |
| 191 dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset())); |
| 192 |
| 193 auto ruleset_handle = CreateRulesetHandle(); |
| 194 |
| 195 AsyncDocumentSubresourceFilter::InitializationParams params( |
| 196 GURL("http://example.com")); |
| 197 |
| 198 TestActivationStateCallbackReceiver activation_state; |
| 199 auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>( |
| 200 ruleset_handle.get(), std::move(params), activation_state.callback(), |
| 201 base::OnceClosure()); |
| 202 |
| 203 RunUntilIdle(); |
| 204 activation_state.Expect(ActivationState(ActivationLevel::DISABLED)); |
| 205 } |
| 206 |
| 207 TEST_F(AsyncDocumentSubresourceFilterTest, GetLoadPolicyForSubdocument) { |
| 208 dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset())); |
| 209 auto ruleset_handle = CreateRulesetHandle(); |
| 210 |
| 211 AsyncDocumentSubresourceFilter::InitializationParams params( |
| 212 GURL("http://example.com")); |
| 213 |
| 214 TestActivationStateCallbackReceiver activation_state; |
| 215 auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>( |
| 216 ruleset_handle.get(), std::move(params), activation_state.callback(), |
| 217 base::OnceClosure()); |
| 218 |
| 219 LoadPolicyCallbackReceiver load_policy_1; |
| 220 LoadPolicyCallbackReceiver load_policy_2; |
| 221 filter->GetLoadPolicyForSubdocument( |
| 222 GURL("http://example.com/allow-this.html"), load_policy_1.callback()); |
| 223 filter->GetLoadPolicyForSubdocument( |
| 224 GURL("http://example.com/block-this.html"), load_policy_2.callback()); |
| 225 |
| 226 RunUntilIdle(); |
| 227 load_policy_1.Expect(AsyncDocumentSubresourceFilter::LoadPolicy::Allow); |
| 228 load_policy_2.Expect(AsyncDocumentSubresourceFilter::LoadPolicy::Disallow); |
| 229 } |
| 230 |
| 231 TEST_F(AsyncDocumentSubresourceFilterTest, FirstDisallowedLoadIsReported) { |
| 232 dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset())); |
| 233 auto ruleset_handle = CreateRulesetHandle(); |
| 234 |
| 235 TestCallbackReceiver first_disallowed_load_receiver; |
| 236 AsyncDocumentSubresourceFilter::InitializationParams params( |
| 237 GURL("http://example.com")); |
| 238 |
| 239 TestActivationStateCallbackReceiver activation_state; |
| 240 auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>( |
| 241 ruleset_handle.get(), std::move(params), activation_state.callback(), |
| 242 first_disallowed_load_receiver.closure()); |
| 243 |
| 244 LoadPolicyCallbackReceiver load_policy_1; |
| 245 filter->GetLoadPolicyForSubdocument( |
| 246 GURL("http://example.com/allow-this.html"), load_policy_1.callback()); |
| 247 RunUntilIdle(); |
| 248 load_policy_1.Expect(AsyncDocumentSubresourceFilter::LoadPolicy::Allow); |
| 249 EXPECT_EQ(0, first_disallowed_load_receiver.callback_count()); |
| 250 |
| 251 LoadPolicyCallbackReceiver load_policy_2; |
| 252 filter->GetLoadPolicyForSubdocument( |
| 253 GURL("http://example.com/block-this.html"), load_policy_2.callback()); |
| 254 RunUntilIdle(); |
| 255 load_policy_2.Expect(AsyncDocumentSubresourceFilter::LoadPolicy::Disallow); |
| 256 EXPECT_EQ(0, first_disallowed_load_receiver.callback_count()); |
| 257 |
| 258 filter->ReportDisallowedLoad(); |
| 259 EXPECT_EQ(1, first_disallowed_load_receiver.callback_count()); |
| 260 RunUntilIdle(); |
| 261 } |
| 262 |
| 263 } // namespace subresource_filter |
OLD | NEW |