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