OLD | NEW |
---|---|
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/subresource_filter/content/common/document_subresource_filt er.h" | 5 #include "components/subresource_filter/core/common/document_subresource_filter. h" |
6 | 6 |
7 #include "base/bind.h" | |
8 #include "base/callback.h" | |
9 #include "base/files/file.h" | |
engedy
2017/02/17 16:44:05
Still needed for move constructor on line 144.
pkalinnikov
2017/02/17 17:16:48
Done.
| |
10 #include "base/macros.h" | |
engedy
2017/02/17 16:44:05
Would keep this as well, it seems a bit awkward to
pkalinnikov
2017/02/17 17:16:48
Done.
| |
11 #include "base/memory/ref_counted.h" | |
12 #include "base/strings/string_piece.h" | 7 #include "base/strings/string_piece.h" |
13 #include "components/subresource_filter/core/common/memory_mapped_ruleset.h" | 8 #include "components/subresource_filter/core/common/memory_mapped_ruleset.h" |
14 #include "components/subresource_filter/core/common/test_ruleset_creator.h" | 9 #include "components/subresource_filter/core/common/test_ruleset_creator.h" |
15 #include "components/subresource_filter/core/common/test_ruleset_utils.h" | 10 #include "components/subresource_filter/core/common/test_ruleset_utils.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 11 #include "testing/gtest/include/gtest/gtest.h" |
17 #include "third_party/WebKit/public/platform/WebURL.h" | |
18 #include "third_party/WebKit/public/platform/WebURLRequest.h" | |
19 #include "url/gurl.h" | |
20 | 12 |
21 namespace subresource_filter { | 13 namespace subresource_filter { |
22 | 14 |
23 namespace { | 15 namespace { |
24 | 16 |
25 constexpr auto kDisabled = ActivationLevel::DISABLED; | 17 constexpr auto kDisabled = ActivationLevel::DISABLED; |
26 constexpr auto kDryRun = ActivationLevel::DRYRUN; | 18 constexpr auto kDryRun = ActivationLevel::DRYRUN; |
27 constexpr auto kEnabled = ActivationLevel::ENABLED; | 19 constexpr auto kEnabled = ActivationLevel::ENABLED; |
28 | 20 |
29 const char kTestAlphaURL[] = "http://example.com/alpha"; | 21 constexpr auto kImageType = proto::ELEMENT_TYPE_IMAGE; |
30 const char kTestAlphaDataURI[] = "data:text/plain,alpha"; | 22 constexpr auto kSubdocumentType = proto::ELEMENT_TYPE_SUBDOCUMENT; |
31 const char kTestBetaURL[] = "http://example.com/beta"; | |
32 | 23 |
33 const char kTestAlphaURLPathSuffix[] = "alpha"; | 24 constexpr const char kTestAlphaURL[] = "http://example.com/alpha"; |
25 constexpr const char kTestAlphaDataURI[] = "data:text/plain,alpha"; | |
26 constexpr const char kTestBetaURL[] = "http://example.com/beta"; | |
34 | 27 |
35 class TestCallbackReceiver { | 28 constexpr const char kTestAlphaURLPathSuffix[] = "alpha"; |
36 public: | |
37 TestCallbackReceiver() = default; | |
38 base::OnceClosure closure() { | |
39 return base::BindOnce(&TestCallbackReceiver::CallbackMethod, | |
40 base::Unretained(this)); | |
41 } | |
42 size_t callback_count() const { return callback_count_; } | |
43 | |
44 private: | |
45 void CallbackMethod() { ++callback_count_; } | |
46 | |
47 size_t callback_count_ = 0; | |
48 | |
49 DISALLOW_COPY_AND_ASSIGN(TestCallbackReceiver); | |
50 }; | |
51 | 29 |
52 } // namespace | 30 } // namespace |
53 | 31 |
54 // Tests for DocumentSubresourceFilter class. ---------------------------------- | 32 // Tests for DocumentSubresourceFilter class. ---------------------------------- |
55 | 33 |
56 class DocumentSubresourceFilterTest : public ::testing::Test { | 34 class DocumentSubresourceFilterTest : public ::testing::Test { |
57 public: | 35 public: |
58 DocumentSubresourceFilterTest() {} | 36 DocumentSubresourceFilterTest() {} |
59 | 37 |
60 protected: | 38 protected: |
(...skipping 14 matching lines...) Expand all Loading... | |
75 const MemoryMappedRuleset* ruleset() { return ruleset_.get(); } | 53 const MemoryMappedRuleset* ruleset() { return ruleset_.get(); } |
76 | 54 |
77 private: | 55 private: |
78 testing::TestRulesetCreator test_ruleset_creator_; | 56 testing::TestRulesetCreator test_ruleset_creator_; |
79 scoped_refptr<const MemoryMappedRuleset> ruleset_; | 57 scoped_refptr<const MemoryMappedRuleset> ruleset_; |
80 | 58 |
81 DISALLOW_COPY_AND_ASSIGN(DocumentSubresourceFilterTest); | 59 DISALLOW_COPY_AND_ASSIGN(DocumentSubresourceFilterTest); |
82 }; | 60 }; |
83 | 61 |
84 TEST_F(DocumentSubresourceFilterTest, DryRun) { | 62 TEST_F(DocumentSubresourceFilterTest, DryRun) { |
85 blink::WebURLRequest::RequestContext request_context = | |
86 blink::WebURLRequest::RequestContextImage; | |
87 TestCallbackReceiver first_disallowed_load_callback_receiver; | |
88 | |
89 ActivationState activation_state(kDryRun); | 63 ActivationState activation_state(kDryRun); |
90 activation_state.measure_performance = true; | 64 activation_state.measure_performance = true; |
91 DocumentSubresourceFilter filter( | 65 DocumentSubresourceFilter filter(url::Origin(), activation_state, ruleset()); |
92 url::Origin(), activation_state, ruleset(), | |
93 first_disallowed_load_callback_receiver.closure()); | |
94 | 66 |
95 EXPECT_EQ(blink::WebDocumentSubresourceFilter::WouldDisallow, | 67 EXPECT_EQ(LoadPolicy::WOULD_DISALLOW, |
96 filter.getLoadPolicy(GURL(kTestAlphaURL), request_context)); | 68 filter.GetLoadPolicy(GURL(kTestAlphaURL), kImageType)); |
97 EXPECT_EQ(blink::WebDocumentSubresourceFilter::Allow, | 69 EXPECT_EQ(LoadPolicy::ALLOW, |
98 filter.getLoadPolicy(GURL(kTestAlphaDataURI), request_context)); | 70 filter.GetLoadPolicy(GURL(kTestAlphaDataURI), kImageType)); |
99 EXPECT_EQ(blink::WebDocumentSubresourceFilter::Allow, | 71 EXPECT_EQ(LoadPolicy::ALLOW, |
100 filter.getLoadPolicy(GURL(kTestBetaURL), request_context)); | 72 filter.GetLoadPolicy(GURL(kTestBetaURL), kImageType)); |
101 EXPECT_EQ(blink::WebDocumentSubresourceFilter::WouldDisallow, | 73 EXPECT_EQ(LoadPolicy::WOULD_DISALLOW, |
102 filter.GetLoadPolicyForSubdocument(GURL(kTestAlphaURL))); | 74 filter.GetLoadPolicy(GURL(kTestAlphaURL), kSubdocumentType)); |
103 EXPECT_EQ(blink::WebDocumentSubresourceFilter::Allow, | 75 EXPECT_EQ(LoadPolicy::ALLOW, |
104 filter.GetLoadPolicyForSubdocument(GURL(kTestBetaURL))); | 76 filter.GetLoadPolicy(GURL(kTestBetaURL), kSubdocumentType)); |
105 | 77 |
106 const auto& statistics = filter.statistics(); | 78 const auto& statistics = filter.statistics(); |
107 EXPECT_EQ(5, statistics.num_loads_total); | 79 EXPECT_EQ(5, statistics.num_loads_total); |
108 EXPECT_EQ(4, statistics.num_loads_evaluated); | 80 EXPECT_EQ(4, statistics.num_loads_evaluated); |
109 EXPECT_EQ(2, statistics.num_loads_matching_rules); | 81 EXPECT_EQ(2, statistics.num_loads_matching_rules); |
110 EXPECT_EQ(0, statistics.num_loads_disallowed); | 82 EXPECT_EQ(0, statistics.num_loads_disallowed); |
111 | |
112 EXPECT_EQ(0u, first_disallowed_load_callback_receiver.callback_count()); | |
113 } | 83 } |
114 | 84 |
115 TEST_F(DocumentSubresourceFilterTest, Enabled) { | 85 TEST_F(DocumentSubresourceFilterTest, Enabled) { |
116 auto test_impl = [this](bool measure_performance) { | 86 auto test_impl = [this](bool measure_performance) { |
117 blink::WebURLRequest::RequestContext request_context = | |
118 blink::WebURLRequest::RequestContextImage; | |
119 ActivationState activation_state(kEnabled); | 87 ActivationState activation_state(kEnabled); |
120 activation_state.measure_performance = measure_performance; | 88 activation_state.measure_performance = measure_performance; |
121 DocumentSubresourceFilter filter(url::Origin(), activation_state, ruleset(), | 89 DocumentSubresourceFilter filter(url::Origin(), activation_state, |
122 base::OnceClosure()); | 90 ruleset()); |
123 | 91 |
124 EXPECT_EQ(blink::WebDocumentSubresourceFilter::Disallow, | 92 EXPECT_EQ(LoadPolicy::DISALLOW, |
125 filter.getLoadPolicy(GURL(kTestAlphaURL), request_context)); | 93 filter.GetLoadPolicy(GURL(kTestAlphaURL), kImageType)); |
126 EXPECT_EQ(blink::WebDocumentSubresourceFilter::Allow, | 94 EXPECT_EQ(LoadPolicy::ALLOW, |
127 filter.getLoadPolicy(GURL(kTestAlphaDataURI), request_context)); | 95 filter.GetLoadPolicy(GURL(kTestAlphaDataURI), kImageType)); |
128 EXPECT_EQ(blink::WebDocumentSubresourceFilter::Allow, | 96 EXPECT_EQ(LoadPolicy::ALLOW, |
129 filter.getLoadPolicy(GURL(kTestBetaURL), request_context)); | 97 filter.GetLoadPolicy(GURL(kTestBetaURL), kImageType)); |
130 EXPECT_EQ(blink::WebDocumentSubresourceFilter::Disallow, | 98 EXPECT_EQ(LoadPolicy::DISALLOW, |
131 filter.GetLoadPolicyForSubdocument(GURL(kTestAlphaURL))); | 99 filter.GetLoadPolicy(GURL(kTestAlphaURL), kSubdocumentType)); |
132 EXPECT_EQ(blink::WebDocumentSubresourceFilter::Allow, | 100 EXPECT_EQ(LoadPolicy::ALLOW, |
133 filter.GetLoadPolicyForSubdocument(GURL(kTestBetaURL))); | 101 filter.GetLoadPolicy(GURL(kTestBetaURL), kSubdocumentType)); |
134 | 102 |
135 const auto& statistics = filter.statistics(); | 103 const auto& statistics = filter.statistics(); |
136 EXPECT_EQ(5, statistics.num_loads_total); | 104 EXPECT_EQ(5, statistics.num_loads_total); |
137 EXPECT_EQ(4, statistics.num_loads_evaluated); | 105 EXPECT_EQ(4, statistics.num_loads_evaluated); |
138 EXPECT_EQ(2, statistics.num_loads_matching_rules); | 106 EXPECT_EQ(2, statistics.num_loads_matching_rules); |
139 EXPECT_EQ(2, statistics.num_loads_disallowed); | 107 EXPECT_EQ(2, statistics.num_loads_disallowed); |
140 | 108 |
141 if (!measure_performance) { | 109 if (!measure_performance) { |
142 EXPECT_TRUE(statistics.evaluation_total_cpu_duration.is_zero()); | 110 EXPECT_TRUE(statistics.evaluation_total_cpu_duration.is_zero()); |
143 EXPECT_TRUE(statistics.evaluation_total_wall_duration.is_zero()); | 111 EXPECT_TRUE(statistics.evaluation_total_wall_duration.is_zero()); |
144 } | 112 } |
145 // Otherwise, don't expect |total_duration| to be non-zero, although it | 113 // Otherwise, don't expect |total_duration| to be non-zero, although it |
146 // practically is (when timer is supported). | 114 // practically is (when timer is supported). |
147 }; | 115 }; |
148 | 116 |
149 test_impl(true /* measure_performance */); | 117 test_impl(true /* measure_performance */); |
150 test_impl(false /* measure_performance */); | 118 test_impl(false /* measure_performance */); |
151 } | 119 } |
152 | 120 |
153 TEST_F(DocumentSubresourceFilterTest, | |
154 CallbackFiredExactlyOnceAfterFirstDisallowedLoad) { | |
155 TestCallbackReceiver first_disallowed_load_callback_receiver; | |
156 | |
157 ActivationState activation_state(kEnabled); | |
158 activation_state.measure_performance = true; | |
159 DocumentSubresourceFilter filter( | |
160 url::Origin(), activation_state, ruleset(), | |
161 first_disallowed_load_callback_receiver.closure()); | |
162 | |
163 EXPECT_EQ(0u, first_disallowed_load_callback_receiver.callback_count()); | |
164 filter.reportDisallowedLoad(); | |
165 EXPECT_EQ(1u, first_disallowed_load_callback_receiver.callback_count()); | |
166 filter.reportDisallowedLoad(); | |
167 EXPECT_EQ(1u, first_disallowed_load_callback_receiver.callback_count()); | |
168 } | |
169 | |
170 // Tests for ComputeActivationState functions. --------------------------------- | 121 // Tests for ComputeActivationState functions. --------------------------------- |
171 | 122 |
172 class SubresourceFilterComputeActivationStateTest : public ::testing::Test { | 123 class SubresourceFilterComputeActivationStateTest : public ::testing::Test { |
173 public: | 124 public: |
174 SubresourceFilterComputeActivationStateTest() {} | 125 SubresourceFilterComputeActivationStateTest() {} |
175 | 126 |
176 protected: | 127 protected: |
177 void SetUp() override { | 128 void SetUp() override { |
178 constexpr int32_t kDocument = proto::ACTIVATION_TYPE_DOCUMENT; | 129 constexpr int32_t kDocument = proto::ACTIVATION_TYPE_DOCUMENT; |
179 constexpr int32_t kGenericBlock = proto::ACTIVATION_TYPE_GENERICBLOCK; | 130 constexpr int32_t kGenericBlock = proto::ACTIVATION_TYPE_GENERICBLOCK; |
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
329 for (const auto& url_string : test_case.ancestor_document_urls) | 280 for (const auto& url_string : test_case.ancestor_document_urls) |
330 ancestor_document_urls.emplace_back(url_string); | 281 ancestor_document_urls.emplace_back(url_string); |
331 | 282 |
332 ActivationState activation_state = ComputeActivationState( | 283 ActivationState activation_state = ComputeActivationState( |
333 test_case.activation_level, false, ancestor_document_urls, ruleset()); | 284 test_case.activation_level, false, ancestor_document_urls, ruleset()); |
334 EXPECT_EQ(test_case.expected_activation_state, activation_state); | 285 EXPECT_EQ(test_case.expected_activation_state, activation_state); |
335 } | 286 } |
336 } | 287 } |
337 | 288 |
338 } // namespace subresource_filter | 289 } // namespace subresource_filter |
OLD | NEW |