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/core/browser/subresource_filter_features .h" | 5 #include "components/subresource_filter/core/browser/subresource_filter_features .h" |
6 | 6 |
7 #include <map> | |
8 #include <ostream> | |
9 #include <sstream> | |
7 #include <string> | 10 #include <string> |
11 #include <tuple> | |
8 #include <utility> | 12 #include <utility> |
9 | 13 |
14 #include "base/json/json_writer.h" | |
10 #include "base/lazy_instance.h" | 15 #include "base/lazy_instance.h" |
11 #include "base/metrics/field_trial_params.h" | 16 #include "base/metrics/field_trial_params.h" |
12 #include "base/strings/string_number_conversions.h" | 17 #include "base/strings/string_number_conversions.h" |
13 #include "base/strings/string_piece.h" | 18 #include "base/strings/string_piece.h" |
14 #include "base/strings/string_split.h" | 19 #include "base/strings/string_split.h" |
15 #include "base/strings/string_util.h" | 20 #include "base/strings/string_util.h" |
16 #include "base/synchronization/lock.h" | 21 #include "base/synchronization/lock.h" |
22 #include "base/values.h" | |
17 #include "components/variations/variations_associated_data.h" | 23 #include "components/variations/variations_associated_data.h" |
18 | 24 |
19 namespace subresource_filter { | 25 namespace subresource_filter { |
20 | 26 |
21 namespace { | 27 namespace { |
22 | 28 |
29 // Helpers -------------------------------------------------------------------- | |
30 | |
31 class CommaSeparatedStrings { | |
32 public: | |
33 CommaSeparatedStrings(std::string comma_separated_strings) | |
34 : backing_string_(comma_separated_strings), | |
35 pieces_(base::SplitStringPiece(backing_string_, | |
36 ",", | |
37 base::TRIM_WHITESPACE, | |
38 base::SPLIT_WANT_NONEMPTY)) {} | |
39 | |
40 bool CaseInsensitiveContains(base::StringPiece lowercase_key) const { | |
41 const auto predicate = [lowercase_key](base::StringPiece element) { | |
42 return base::LowerCaseEqualsASCII(element, lowercase_key); | |
43 }; | |
44 return !!std::count_if(pieces_.begin(), pieces_.end(), predicate); | |
45 } | |
46 | |
47 private: | |
48 const std::string backing_string_; | |
49 const std::vector<base::StringPiece> pieces_; | |
50 | |
51 DISALLOW_COPY_AND_ASSIGN(CommaSeparatedStrings); | |
52 }; | |
53 | |
23 std::string TakeVariationParamOrReturnEmpty( | 54 std::string TakeVariationParamOrReturnEmpty( |
24 std::map<std::string, std::string>* params, | 55 std::map<std::string, std::string>* params, |
25 const std::string& key) { | 56 const std::string& key) { |
26 auto it = params->find(key); | 57 auto it = params->find(key); |
27 if (it == params->end()) | 58 if (it == params->end()) |
28 return std::string(); | 59 return std::string(); |
29 std::string value = std::move(it->second); | 60 std::string value = std::move(it->second); |
30 params->erase(it); | 61 params->erase(it); |
31 return value; | 62 return value; |
32 } | 63 } |
33 | 64 |
34 ActivationLevel ParseActivationLevel(const base::StringPiece activation_level) { | 65 ActivationLevel ParseActivationLevel(const base::StringPiece activation_level) { |
35 if (base::LowerCaseEqualsASCII(activation_level, kActivationLevelEnabled)) | 66 if (base::LowerCaseEqualsASCII(activation_level, kActivationLevelEnabled)) |
36 return ActivationLevel::ENABLED; | 67 return ActivationLevel::ENABLED; |
37 else if (base::LowerCaseEqualsASCII(activation_level, kActivationLevelDryRun)) | 68 else if (base::LowerCaseEqualsASCII(activation_level, kActivationLevelDryRun)) |
38 return ActivationLevel::DRYRUN; | 69 return ActivationLevel::DRYRUN; |
39 return ActivationLevel::DISABLED; | 70 return ActivationLevel::DISABLED; |
40 } | 71 } |
41 | 72 |
42 ActivationScope ParseActivationScope(const base::StringPiece activation_scope) { | 73 ActivationScope ParseActivationScope(const base::StringPiece activation_scope) { |
43 if (base::LowerCaseEqualsASCII(activation_scope, kActivationScopeAllSites)) | 74 if (base::LowerCaseEqualsASCII(activation_scope, kActivationScopeAllSites)) |
44 return ActivationScope::ALL_SITES; | 75 return ActivationScope::ALL_SITES; |
45 else if (base::LowerCaseEqualsASCII(activation_scope, | 76 else if (base::LowerCaseEqualsASCII(activation_scope, |
46 kActivationScopeActivationList)) | 77 kActivationScopeActivationList)) |
47 return ActivationScope::ACTIVATION_LIST; | 78 return ActivationScope::ACTIVATION_LIST; |
48 return ActivationScope::NO_SITES; | 79 return ActivationScope::NO_SITES; |
49 } | 80 } |
50 | 81 |
51 ActivationList ParseActivationList(const base::StringPiece activation_lists) { | 82 ActivationList ParseActivationList(std::string activation_lists_string) { |
52 ActivationList activation_list_type = ActivationList::NONE; | 83 ActivationList activation_list_type = ActivationList::NONE; |
53 for (const base::StringPiece& activation_list : | 84 CommaSeparatedStrings activation_lists(std::move(activation_lists_string)); |
54 base::SplitStringPiece(activation_lists, ",", base::TRIM_WHITESPACE, | 85 if (activation_lists.CaseInsensitiveContains( |
55 base::SPLIT_WANT_NONEMPTY)) { | 86 kActivationListPhishingInterstitial)) { |
56 if (base::LowerCaseEqualsASCII(activation_list, | 87 return ActivationList::PHISHING_INTERSTITIAL; |
57 kActivationListPhishingInterstitial)) { | 88 } else if (activation_lists.CaseInsensitiveContains( |
58 return ActivationList::PHISHING_INTERSTITIAL; | 89 kActivationListSocialEngineeringAdsInterstitial)) { |
59 } else if (base::LowerCaseEqualsASCII( | 90 activation_list_type = ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL; |
60 activation_list, | 91 } else if (activation_lists.CaseInsensitiveContains( |
61 kActivationListSocialEngineeringAdsInterstitial)) { | 92 kActivationListSubresourceFilter)) { |
62 activation_list_type = ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL; | 93 activation_list_type = ActivationList::SUBRESOURCE_FILTER; |
63 } else if (base::LowerCaseEqualsASCII(activation_list, | |
64 kActivationListSubresourceFilter)) { | |
65 activation_list_type = ActivationList::SUBRESOURCE_FILTER; | |
66 } | |
67 } | 94 } |
68 return activation_list_type; | 95 return activation_list_type; |
69 } | 96 } |
70 | 97 |
71 double ParsePerformanceMeasurementRate(const std::string& rate) { | 98 double ParsePerformanceMeasurementRate(const std::string& rate) { |
72 double value = 0; | 99 double value = 0.0; |
73 if (!base::StringToDouble(rate, &value) || value < 0) | 100 if (!base::StringToDouble(rate, &value) || value < 0) |
74 return 0; | 101 return 0.0; |
75 return value < 1 ? value : 1; | 102 return value < 1 ? value : 1; |
76 } | 103 } |
77 | 104 |
78 bool ParseBool(const base::StringPiece value) { | 105 bool ParseBool(const base::StringPiece value) { |
79 return base::LowerCaseEqualsASCII(value, "true"); | 106 return base::LowerCaseEqualsASCII(value, "true"); |
80 } | 107 } |
81 | 108 |
82 Configuration ParseFieldTrialConfiguration() { | 109 int ParseInt(const base::StringPiece value) { |
110 int result = 0; | |
111 base::StringToInt(value, &result); | |
112 return result; | |
113 } | |
114 | |
115 std::vector<Configuration> FillEnabledPresetConfigurations( | |
116 std::map<std::string, std::string>* params) { | |
117 const struct { | |
118 const char* name; | |
119 bool enabled_by_default; | |
120 Configuration (*factory_method)(); | |
121 } kAvailablePresetConfigurations[] = { | |
122 {kPresetLiveRunOnPhishingSites, false, | |
123 &Configuration::MakePresetForLiveRunOnPhishingSites}, | |
124 {kPresetPerformanceTestingDryRunOnAllSites, false, | |
125 &Configuration::MakePresetForPerformanceTestingDryRunOnAllSites}}; | |
126 | |
127 CommaSeparatedStrings enabled_presets( | |
128 TakeVariationParamOrReturnEmpty(params, kEnablePresetsParameterName)); | |
129 CommaSeparatedStrings disabled_presets( | |
130 TakeVariationParamOrReturnEmpty(params, kDisablePresetsParameterName)); | |
131 | |
132 std::vector<Configuration> enabled_configurations; | |
133 for (const auto& available_preset : kAvailablePresetConfigurations) { | |
134 if ((enabled_presets.CaseInsensitiveContains(available_preset.name) || | |
135 available_preset.enabled_by_default) && | |
136 !disabled_presets.CaseInsensitiveContains(available_preset.name)) { | |
137 enabled_configurations.push_back(available_preset.factory_method()); | |
138 } | |
139 } | |
140 | |
141 return enabled_configurations; | |
142 } | |
143 | |
144 Configuration ParseExperimentalConfiguration( | |
145 std::map<std::string, std::string>* params) { | |
83 Configuration configuration; | 146 Configuration configuration; |
84 | 147 |
85 std::map<std::string, std::string> params; | 148 // ActivationConditions: |
86 base::GetFieldTrialParamsByFeature(kSafeBrowsingSubresourceFilter, ¶ms); | 149 configuration.activation_conditions.activation_scope = ParseActivationScope( |
150 TakeVariationParamOrReturnEmpty(params, kActivationScopeParameterName)); | |
87 | 151 |
88 configuration.activation_level = ParseActivationLevel( | 152 configuration.activation_conditions.activation_list = ParseActivationList( |
89 TakeVariationParamOrReturnEmpty(¶ms, kActivationLevelParameterName)); | 153 TakeVariationParamOrReturnEmpty(params, kActivationListsParameterName)); |
90 | 154 |
91 configuration.activation_scope = ParseActivationScope( | 155 configuration.activation_conditions.priority = |
92 TakeVariationParamOrReturnEmpty(¶ms, kActivationScopeParameterName)); | 156 ParseInt(TakeVariationParamOrReturnEmpty( |
157 params, kActivationPriorityParameterName)); | |
93 | 158 |
94 configuration.activation_list = ParseActivationList( | 159 // ActivationOptions: |
95 TakeVariationParamOrReturnEmpty(¶ms, kActivationListsParameterName)); | 160 configuration.activation_options.activation_level = ParseActivationLevel( |
161 TakeVariationParamOrReturnEmpty(params, kActivationLevelParameterName)); | |
96 | 162 |
97 configuration.performance_measurement_rate = | 163 configuration.activation_options.performance_measurement_rate = |
98 ParsePerformanceMeasurementRate(TakeVariationParamOrReturnEmpty( | 164 ParsePerformanceMeasurementRate(TakeVariationParamOrReturnEmpty( |
99 ¶ms, kPerformanceMeasurementRateParameterName)); | 165 params, kPerformanceMeasurementRateParameterName)); |
100 | 166 |
101 configuration.should_suppress_notifications = | 167 configuration.activation_options.should_suppress_notifications = |
102 ParseBool(TakeVariationParamOrReturnEmpty( | 168 ParseBool(TakeVariationParamOrReturnEmpty( |
103 ¶ms, kSuppressNotificationsParameterName)); | 169 params, kSuppressNotificationsParameterName)); |
104 | 170 |
105 configuration.ruleset_flavor = | 171 configuration.activation_options.should_whitelist_site_on_reload = |
106 TakeVariationParamOrReturnEmpty(¶ms, kRulesetFlavorParameterName); | 172 ParseBool(TakeVariationParamOrReturnEmpty( |
173 params, kWhitelistSiteOnReloadParameterName)); | |
107 | 174 |
108 configuration.should_whitelist_site_on_reload = | 175 // GeneralSettings: |
109 ParseBool(TakeVariationParamOrReturnEmpty( | 176 configuration.general_settings.ruleset_flavor = |
110 ¶ms, kWhitelistSiteOnReloadParameterName)); | 177 TakeVariationParamOrReturnEmpty(params, kRulesetFlavorParameterName); |
111 | 178 |
112 return configuration; | 179 return configuration; |
113 } | 180 } |
114 | 181 |
182 std::vector<Configuration> ParseEnabledConfigurations() { | |
183 std::map<std::string, std::string> params; | |
184 base::GetFieldTrialParamsByFeature(kSafeBrowsingSubresourceFilter, ¶ms); | |
185 | |
186 std::vector<Configuration> configs = FillEnabledPresetConfigurations(¶ms); | |
187 | |
188 Configuration experimental_config = ParseExperimentalConfiguration(¶ms); | |
189 configs.push_back(std::move(experimental_config)); | |
190 | |
191 return configs; | |
192 } | |
193 | |
194 template <class T> | |
195 std::string StreamToString(const T& value) { | |
196 std::ostringstream oss; | |
197 oss << value; | |
198 return oss.str(); | |
199 } | |
200 | |
201 std::vector<Configuration> SortConfigsByDecreasingPriority( | |
202 std::vector<Configuration> configs) { | |
203 auto comp = [](const Configuration& a, const Configuration& b) { | |
204 return a.activation_conditions.priority > b.activation_conditions.priority; | |
205 }; | |
206 std::sort(configs.begin(), configs.end(), comp); | |
207 return configs; | |
208 } | |
209 | |
210 std::string GetLexicographicallyGreatestRulesetFlavor( | |
211 const std::vector<Configuration>& configs) { | |
212 base::StringPiece greatest_flavor; | |
213 for (const auto& config : configs) { | |
214 base::StringPiece flavor = config.general_settings.ruleset_flavor; | |
215 if (flavor > greatest_flavor) | |
216 greatest_flavor = flavor; | |
217 } | |
218 return greatest_flavor.as_string(); | |
219 } | |
220 | |
221 // Globals -------------------------------------------------------------------- | |
222 | |
115 base::LazyInstance<base::Lock>::Leaky g_active_configurations_lock = | 223 base::LazyInstance<base::Lock>::Leaky g_active_configurations_lock = |
116 LAZY_INSTANCE_INITIALIZER; | 224 LAZY_INSTANCE_INITIALIZER; |
117 | 225 |
118 base::LazyInstance<scoped_refptr<ConfigurationList>>::Leaky | 226 base::LazyInstance<scoped_refptr<ConfigurationList>>::Leaky |
119 g_active_configurations = LAZY_INSTANCE_INITIALIZER; | 227 g_active_configurations = LAZY_INSTANCE_INITIALIZER; |
120 | 228 |
121 } // namespace | 229 } // namespace |
122 | 230 |
231 // Constant definitions ------------------------------------------------------- | |
232 | |
123 const base::Feature kSafeBrowsingSubresourceFilter{ | 233 const base::Feature kSafeBrowsingSubresourceFilter{ |
124 "SubresourceFilter", base::FEATURE_DISABLED_BY_DEFAULT}; | 234 "SubresourceFilter", base::FEATURE_DISABLED_BY_DEFAULT}; |
125 | 235 |
126 const base::Feature kSafeBrowsingSubresourceFilterExperimentalUI{ | 236 const base::Feature kSafeBrowsingSubresourceFilterExperimentalUI{ |
127 "SubresourceFilterExperimentalUI", base::FEATURE_DISABLED_BY_DEFAULT}; | 237 "SubresourceFilterExperimentalUI", base::FEATURE_DISABLED_BY_DEFAULT}; |
128 | 238 |
129 // Legacy name `activation_state` is used in variation parameters. | 239 // Legacy name `activation_state` is used in variation parameters. |
130 const char kActivationLevelParameterName[] = "activation_state"; | 240 const char kActivationLevelParameterName[] = "activation_state"; |
131 const char kActivationLevelDryRun[] = "dryrun"; | 241 const char kActivationLevelDryRun[] = "dryrun"; |
132 const char kActivationLevelEnabled[] = "enabled"; | 242 const char kActivationLevelEnabled[] = "enabled"; |
133 const char kActivationLevelDisabled[] = "disabled"; | 243 const char kActivationLevelDisabled[] = "disabled"; |
134 | 244 |
135 const char kActivationScopeParameterName[] = "activation_scope"; | 245 const char kActivationScopeParameterName[] = "activation_scope"; |
136 const char kActivationScopeAllSites[] = "all_sites"; | 246 const char kActivationScopeAllSites[] = "all_sites"; |
137 const char kActivationScopeActivationList[] = "activation_list"; | 247 const char kActivationScopeActivationList[] = "activation_list"; |
138 const char kActivationScopeNoSites[] = "no_sites"; | 248 const char kActivationScopeNoSites[] = "no_sites"; |
139 | 249 |
140 const char kActivationListsParameterName[] = "activation_lists"; | 250 const char kActivationListsParameterName[] = "activation_lists"; |
141 const char kActivationListSocialEngineeringAdsInterstitial[] = | 251 const char kActivationListSocialEngineeringAdsInterstitial[] = |
142 "social_engineering_ads_interstitial"; | 252 "social_engineering_ads_interstitial"; |
143 const char kActivationListPhishingInterstitial[] = "phishing_interstitial"; | 253 const char kActivationListPhishingInterstitial[] = "phishing_interstitial"; |
144 const char kActivationListSubresourceFilter[] = "subresource_filter"; | 254 const char kActivationListSubresourceFilter[] = "subresource_filter"; |
145 | 255 |
146 const char kRulesetFlavorParameterName[] = "ruleset_flavor"; | 256 const char kActivationPriorityParameterName[] = "activation_priority"; |
147 | 257 |
148 const char kPerformanceMeasurementRateParameterName[] = | 258 const char kPerformanceMeasurementRateParameterName[] = |
149 "performance_measurement_rate"; | 259 "performance_measurement_rate"; |
260 const char kSuppressNotificationsParameterName[] = "suppress_notifications"; | |
261 const char kWhitelistSiteOnReloadParameterName[] = "whitelist_site_on_reload"; | |
150 | 262 |
151 const char kSuppressNotificationsParameterName[] = "suppress_notifications"; | 263 const char kRulesetFlavorParameterName[] = "ruleset_flavor"; |
152 | 264 |
153 const char kWhitelistSiteOnReloadParameterName[] = "whitelist_site_on_reload"; | 265 const char kEnablePresetsParameterName[] = "enable_presets"; |
266 const char kDisablePresetsParameterName[] = "disable_presets"; | |
267 const char kPresetLiveRunOnPhishingSites[] = "liverun_on_phishing_sites"; | |
268 const char kPresetPerformanceTestingDryRunOnAllSites[] = | |
269 "performance_testing_dryrun_on_all_sites"; | |
270 | |
271 // Configuration -------------------------------------------------------------- | |
272 | |
273 // static | |
274 Configuration Configuration::MakePresetForLiveRunOnPhishingSites() { | |
275 Configuration config(ActivationLevel::ENABLED, | |
276 ActivationScope::ACTIVATION_LIST, | |
277 ActivationList::PHISHING_INTERSTITIAL); | |
278 config.activation_conditions.priority = 100; | |
279 return config; | |
280 } | |
281 | |
282 // static | |
283 Configuration Configuration::MakePresetForPerformanceTestingDryRunOnAllSites() { | |
284 Configuration config(ActivationLevel::DRYRUN, ActivationScope::ALL_SITES); | |
285 config.activation_options.performance_measurement_rate = 1.0; | |
286 config.activation_conditions.priority = 50; | |
287 return config; | |
288 } | |
154 | 289 |
155 Configuration::Configuration() = default; | 290 Configuration::Configuration() = default; |
156 Configuration::Configuration(ActivationLevel activation_level, | 291 Configuration::Configuration(ActivationLevel activation_level, |
157 ActivationScope activation_scope, | 292 ActivationScope activation_scope, |
158 ActivationList activation_list) | 293 ActivationList activation_list) { |
159 : activation_level(activation_level), | 294 activation_options.activation_level = activation_level; |
160 activation_scope(activation_scope), | 295 activation_conditions.activation_scope = activation_scope; |
161 activation_list(activation_list) {} | 296 activation_conditions.activation_list = activation_list; |
297 } | |
298 Configuration::Configuration(const Configuration&) = default; | |
162 Configuration::Configuration(Configuration&&) = default; | 299 Configuration::Configuration(Configuration&&) = default; |
163 Configuration::~Configuration() = default; | 300 Configuration::~Configuration() = default; |
301 Configuration& Configuration::operator=(const Configuration&) = default; | |
164 Configuration& Configuration::operator=(Configuration&&) = default; | 302 Configuration& Configuration::operator=(Configuration&&) = default; |
165 | 303 |
304 bool Configuration::operator==(const Configuration& rhs) const { | |
305 const auto tie = [](const Configuration& config) { | |
306 return std::tie(config.activation_conditions.activation_scope, | |
307 config.activation_conditions.activation_list, | |
308 config.activation_conditions.priority, | |
309 config.activation_options.activation_level, | |
310 config.activation_options.performance_measurement_rate, | |
311 config.activation_options.should_whitelist_site_on_reload, | |
312 config.activation_options.should_suppress_notifications, | |
313 config.general_settings.ruleset_flavor); | |
314 }; | |
315 return tie(*this) == tie(rhs); | |
pkalinnikov
2017/05/05 13:29:59
Belated "nice" :)
| |
316 } | |
317 | |
318 bool Configuration::operator!=(const Configuration& rhs) const { | |
319 return !(*this == rhs); | |
320 } | |
321 | |
322 std::ostream& operator<<(std::ostream& os, const Configuration& config) { | |
323 base::DictionaryValue dict; | |
324 dict.SetString("activation_scope", | |
325 StreamToString(config.activation_conditions.activation_scope)); | |
326 dict.SetString("activation_list", | |
327 StreamToString(config.activation_conditions.activation_list)); | |
328 dict.SetInteger("priority", config.activation_conditions.priority); | |
329 dict.SetString("activation_level", | |
330 StreamToString(config.activation_options.activation_level)); | |
331 dict.SetDouble("performance_measurement_rate", | |
332 config.activation_options.performance_measurement_rate); | |
333 dict.SetBoolean("should_suppress_notifications", | |
334 config.activation_options.should_suppress_notifications); | |
335 dict.SetBoolean("should_whitelist_site_on_reload", | |
336 config.activation_options.should_whitelist_site_on_reload); | |
337 dict.SetString("ruleset_flavor", | |
338 StreamToString(config.general_settings.ruleset_flavor)); | |
339 std::string json; | |
340 base::JSONWriter::WriteWithOptions( | |
341 dict, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json); | |
342 return os << json; | |
343 } | |
344 | |
345 // ConfigurationList ---------------------------------------------------------- | |
346 | |
347 ConfigurationList::ConfigurationList(std::vector<Configuration> configs) | |
348 : lexicographically_greatest_ruleset_flavor_( | |
349 GetLexicographicallyGreatestRulesetFlavor(configs)), | |
350 configs_by_decreasing_priority_( | |
351 SortConfigsByDecreasingPriority(std::move(configs))) {} | |
166 ConfigurationList::ConfigurationList(Configuration config) | 352 ConfigurationList::ConfigurationList(Configuration config) |
167 : config_(std::move(config)) {} | 353 : ConfigurationList(std::vector<Configuration>(1, std::move(config))) {} |
168 ConfigurationList::~ConfigurationList() = default; | 354 ConfigurationList::~ConfigurationList() = default; |
169 | 355 |
170 scoped_refptr<ConfigurationList> GetActiveConfigurations() { | 356 scoped_refptr<ConfigurationList> GetEnabledConfigurations() { |
171 base::AutoLock lock(g_active_configurations_lock.Get()); | 357 base::AutoLock lock(g_active_configurations_lock.Get()); |
172 if (!g_active_configurations.Get()) { | 358 if (!g_active_configurations.Get()) { |
173 g_active_configurations.Get() = | 359 g_active_configurations.Get() = |
174 base::MakeShared<ConfigurationList>(ParseFieldTrialConfiguration()); | 360 base::MakeShared<ConfigurationList>(ParseEnabledConfigurations()); |
175 } | 361 } |
176 return g_active_configurations.Get(); | 362 return g_active_configurations.Get(); |
177 } | 363 } |
178 | 364 |
179 namespace testing { | 365 namespace testing { |
180 | 366 |
181 scoped_refptr<ConfigurationList> GetAndSetActivateConfigurations( | 367 scoped_refptr<ConfigurationList> GetAndSetActivateConfigurations( |
182 scoped_refptr<ConfigurationList> new_configs) { | 368 scoped_refptr<ConfigurationList> new_configs) { |
183 base::AutoLock lock(g_active_configurations_lock.Get()); | 369 base::AutoLock lock(g_active_configurations_lock.Get()); |
184 auto old_configs = std::move(g_active_configurations.Get()); | 370 auto old_configs = std::move(g_active_configurations.Get()); |
185 g_active_configurations.Get() = std::move(new_configs); | 371 g_active_configurations.Get() = std::move(new_configs); |
186 return old_configs; | 372 return old_configs; |
187 } | 373 } |
188 | 374 |
189 } // namespace testing | 375 } // namespace testing |
190 | 376 |
191 } // namespace subresource_filter | 377 } // namespace subresource_filter |
OLD | NEW |