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 <climits> | 7 #include <utility> |
8 | 8 |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "base/strings/string_piece.h" | |
11 #include "base/strings/string_util.h" | |
12 #include "base/trace_event/trace_event.h" | 10 #include "base/trace_event/trace_event.h" |
13 #include "components/subresource_filter/core/common/first_party_origin.h" | 11 #include "components/subresource_filter/core/common/first_party_origin.h" |
14 #include "components/subresource_filter/core/common/memory_mapped_ruleset.h" | 12 #include "components/subresource_filter/core/common/memory_mapped_ruleset.h" |
15 #include "components/subresource_filter/core/common/scoped_timers.h" | 13 #include "components/subresource_filter/core/common/scoped_timers.h" |
16 #include "components/subresource_filter/core/common/time_measurements.h" | 14 #include "components/subresource_filter/core/common/time_measurements.h" |
17 #include "third_party/WebKit/public/platform/WebURL.h" | |
18 | 15 |
19 namespace subresource_filter { | 16 namespace subresource_filter { |
20 | 17 |
21 namespace { | 18 namespace { |
22 | 19 |
23 proto::ElementType ToElementType( | |
24 blink::WebURLRequest::RequestContext request_context) { | |
25 switch (request_context) { | |
26 case blink::WebURLRequest::RequestContextAudio: | |
27 case blink::WebURLRequest::RequestContextVideo: | |
28 case blink::WebURLRequest::RequestContextTrack: | |
29 return proto::ELEMENT_TYPE_MEDIA; | |
30 case blink::WebURLRequest::RequestContextBeacon: | |
31 case blink::WebURLRequest::RequestContextPing: | |
32 return proto::ELEMENT_TYPE_PING; | |
33 case blink::WebURLRequest::RequestContextEmbed: | |
34 case blink::WebURLRequest::RequestContextObject: | |
35 case blink::WebURLRequest::RequestContextPlugin: | |
36 return proto::ELEMENT_TYPE_OBJECT; | |
37 case blink::WebURLRequest::RequestContextEventSource: | |
38 case blink::WebURLRequest::RequestContextFetch: | |
39 case blink::WebURLRequest::RequestContextXMLHttpRequest: | |
40 return proto::ELEMENT_TYPE_XMLHTTPREQUEST; | |
41 case blink::WebURLRequest::RequestContextFavicon: | |
42 case blink::WebURLRequest::RequestContextImage: | |
43 case blink::WebURLRequest::RequestContextImageSet: | |
44 return proto::ELEMENT_TYPE_IMAGE; | |
45 case blink::WebURLRequest::RequestContextFont: | |
46 return proto::ELEMENT_TYPE_FONT; | |
47 case blink::WebURLRequest::RequestContextFrame: | |
48 case blink::WebURLRequest::RequestContextForm: | |
49 case blink::WebURLRequest::RequestContextHyperlink: | |
50 case blink::WebURLRequest::RequestContextIframe: | |
51 case blink::WebURLRequest::RequestContextInternal: | |
52 case blink::WebURLRequest::RequestContextLocation: | |
53 return proto::ELEMENT_TYPE_SUBDOCUMENT; | |
54 case blink::WebURLRequest::RequestContextScript: | |
55 case blink::WebURLRequest::RequestContextServiceWorker: | |
56 case blink::WebURLRequest::RequestContextSharedWorker: | |
57 return proto::ELEMENT_TYPE_SCRIPT; | |
58 case blink::WebURLRequest::RequestContextStyle: | |
59 case blink::WebURLRequest::RequestContextXSLT: | |
60 return proto::ELEMENT_TYPE_STYLESHEET; | |
61 | |
62 case blink::WebURLRequest::RequestContextPrefetch: | |
63 case blink::WebURLRequest::RequestContextSubresource: | |
64 return proto::ELEMENT_TYPE_OTHER; | |
65 | |
66 case blink::WebURLRequest::RequestContextCSPReport: | |
67 case blink::WebURLRequest::RequestContextDownload: | |
68 case blink::WebURLRequest::RequestContextImport: | |
69 case blink::WebURLRequest::RequestContextManifest: | |
70 case blink::WebURLRequest::RequestContextUnspecified: | |
71 default: | |
72 return proto::ELEMENT_TYPE_UNSPECIFIED; | |
73 } | |
74 } | |
75 | |
76 ActivationState ComputeActivationStateImpl( | 20 ActivationState ComputeActivationStateImpl( |
77 const GURL& document_url, | 21 const GURL& document_url, |
78 const url::Origin& parent_document_origin, | 22 const url::Origin& parent_document_origin, |
79 const ActivationState& parent_activation_state, | 23 const ActivationState& parent_activation_state, |
80 const IndexedRulesetMatcher& matcher) { | 24 const IndexedRulesetMatcher& matcher) { |
81 ActivationState activation_state = parent_activation_state; | 25 ActivationState activation_state = parent_activation_state; |
82 if (activation_state.filtering_disabled_for_document) | 26 if (activation_state.filtering_disabled_for_document) |
83 return activation_state; | 27 return activation_state; |
84 | 28 |
85 // TODO(pkalinnikov): Match several activation types in a batch. | 29 // TODO(pkalinnikov): Match several activation types in a batch. |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
134 document_url, parent_document_origin, activation_state, matcher); | 78 document_url, parent_document_origin, activation_state, matcher); |
135 parent_document_origin = url::Origin(document_url); | 79 parent_document_origin = url::Origin(document_url); |
136 } | 80 } |
137 | 81 |
138 return activation_state; | 82 return activation_state; |
139 } | 83 } |
140 | 84 |
141 DocumentSubresourceFilter::DocumentSubresourceFilter( | 85 DocumentSubresourceFilter::DocumentSubresourceFilter( |
142 url::Origin document_origin, | 86 url::Origin document_origin, |
143 ActivationState activation_state, | 87 ActivationState activation_state, |
144 scoped_refptr<const MemoryMappedRuleset> ruleset, | 88 scoped_refptr<const MemoryMappedRuleset> ruleset) |
145 base::OnceClosure first_disallowed_load_callback) | |
146 : activation_state_(activation_state), | 89 : activation_state_(activation_state), |
147 ruleset_(std::move(ruleset)), | 90 ruleset_(std::move(ruleset)), |
148 ruleset_matcher_(ruleset_->data(), ruleset_->length()), | 91 ruleset_matcher_(ruleset_->data(), ruleset_->length()) { |
149 first_disallowed_load_callback_( | |
150 std::move(first_disallowed_load_callback)) { | |
151 DCHECK_NE(activation_state_.activation_level, ActivationLevel::DISABLED); | 92 DCHECK_NE(activation_state_.activation_level, ActivationLevel::DISABLED); |
152 if (!activation_state_.filtering_disabled_for_document) | 93 if (!activation_state_.filtering_disabled_for_document) |
153 document_origin_.reset(new FirstPartyOrigin(std::move(document_origin))); | 94 document_origin_.reset(new FirstPartyOrigin(std::move(document_origin))); |
154 } | 95 } |
155 | 96 |
156 DocumentSubresourceFilter::~DocumentSubresourceFilter() = default; | 97 DocumentSubresourceFilter::~DocumentSubresourceFilter() = default; |
157 | 98 |
158 blink::WebDocumentSubresourceFilter::LoadPolicy | 99 LoadPolicy DocumentSubresourceFilter::GetLoadPolicy( |
159 DocumentSubresourceFilter::getLoadPolicy( | 100 const GURL& subresource_url, |
160 const blink::WebURL& resourceUrl, | 101 proto::ElementType subresource_type) { |
161 blink::WebURLRequest::RequestContext request_context) { | 102 TRACE_EVENT1("loader", "DocumentSubresourceFilter::GetLoadPolicy", "url", |
162 ++statistics_.num_loads_total; | 103 subresource_url.spec()); |
163 | 104 |
164 if (activation_state_.filtering_disabled_for_document) | 105 if (activation_state_.filtering_disabled_for_document) |
165 return Allow; | 106 return LoadPolicy::ALLOW; |
166 if (resourceUrl.protocolIs(url::kDataScheme)) | 107 if (subresource_url.SchemeIs(url::kDataScheme)) |
167 return Allow; | 108 return LoadPolicy::ALLOW; |
168 | |
169 // TODO(pkalinnikov): Would be good to avoid converting to GURL. | |
170 return EvaluateLoadPolicy(GURL(resourceUrl), ToElementType(request_context)); | |
171 } | |
172 | |
173 blink::WebDocumentSubresourceFilter::LoadPolicy | |
174 DocumentSubresourceFilter::GetLoadPolicyForSubdocument( | |
175 const GURL& subdocument_url) { | |
176 ++statistics_.num_loads_total; | |
177 | |
178 if (activation_state_.filtering_disabled_for_document) | |
179 return Allow; | |
180 if (subdocument_url.SchemeIs(url::kDataScheme)) | |
181 return Allow; | |
182 return EvaluateLoadPolicy(subdocument_url, proto::ELEMENT_TYPE_SUBDOCUMENT); | |
183 } | |
184 | |
185 void DocumentSubresourceFilter::reportDisallowedLoad() { | |
186 if (first_disallowed_load_callback_.is_null()) | |
187 return; | |
188 std::move(first_disallowed_load_callback_).Run(); | |
189 } | |
190 | |
191 blink::WebDocumentSubresourceFilter::LoadPolicy | |
192 DocumentSubresourceFilter::EvaluateLoadPolicy(const GURL& resource_url, | |
193 proto::ElementType element_type) { | |
194 TRACE_EVENT1("loader", "DocumentSubresourceFilter::EvaluateLoadPolicy", "url", | |
195 resource_url.spec()); | |
196 | 109 |
197 auto wall_duration_timer = ScopedTimers::StartIf( | 110 auto wall_duration_timer = ScopedTimers::StartIf( |
198 activation_state_.measure_performance && | 111 activation_state_.measure_performance && |
199 ScopedThreadTimers::IsSupported(), | 112 ScopedThreadTimers::IsSupported(), |
200 [this](base::TimeDelta delta) { | 113 [this](base::TimeDelta delta) { |
201 statistics_.evaluation_total_wall_duration += delta; | 114 statistics_.evaluation_total_wall_duration += delta; |
202 UMA_HISTOGRAM_MICRO_TIMES( | 115 UMA_HISTOGRAM_MICRO_TIMES( |
203 "SubresourceFilter.SubresourceLoad.Evaluation.WallDuration", delta); | 116 "SubresourceFilter.SubresourceLoad.Evaluation.WallDuration", delta); |
204 }); | 117 }); |
205 auto cpu_duration_timer = ScopedThreadTimers::StartIf( | 118 auto cpu_duration_timer = ScopedThreadTimers::StartIf( |
206 activation_state_.measure_performance, [this](base::TimeDelta delta) { | 119 activation_state_.measure_performance, [this](base::TimeDelta delta) { |
207 statistics_.evaluation_total_cpu_duration += delta; | 120 statistics_.evaluation_total_cpu_duration += delta; |
208 UMA_HISTOGRAM_MICRO_TIMES( | 121 UMA_HISTOGRAM_MICRO_TIMES( |
209 "SubresourceFilter.SubresourceLoad.Evaluation.CPUDuration", delta); | 122 "SubresourceFilter.SubresourceLoad.Evaluation.CPUDuration", delta); |
210 }); | 123 }); |
211 | 124 |
212 ++statistics_.num_loads_evaluated; | 125 ++statistics_.num_loads_evaluated; |
213 DCHECK(document_origin_); | 126 DCHECK(document_origin_); |
214 if (ruleset_matcher_.ShouldDisallowResourceLoad( | 127 if (ruleset_matcher_.ShouldDisallowResourceLoad( |
215 resource_url, *document_origin_, element_type, | 128 subresource_url, *document_origin_, subresource_type, |
216 activation_state_.generic_blocking_rules_disabled)) { | 129 activation_state_.generic_blocking_rules_disabled)) { |
217 ++statistics_.num_loads_matching_rules; | 130 ++statistics_.num_loads_matching_rules; |
218 if (activation_state_.activation_level == ActivationLevel::ENABLED) { | 131 if (activation_state_.activation_level == ActivationLevel::ENABLED) { |
219 ++statistics_.num_loads_disallowed; | 132 ++statistics_.num_loads_disallowed; |
220 return Disallow; | 133 return LoadPolicy::DISALLOW; |
221 } else if (activation_state_.activation_level == ActivationLevel::DRYRUN) { | 134 } else if (activation_state_.activation_level == ActivationLevel::DRYRUN) { |
222 return WouldDisallow; | 135 return LoadPolicy::WOULD_DISALLOW; |
223 } | 136 } |
224 } | 137 } |
225 return Allow; | 138 return LoadPolicy::ALLOW; |
226 } | 139 } |
227 | 140 |
228 } // namespace subresource_filter | 141 } // namespace subresource_filter |
OLD | NEW |