blob: 1442c0106bdd74c9bca191158f08cf2579658fda [file] [log] [blame]
Sebastian Jansson9eb38862018-06-14 16:47:42 +02001/*
Jonas Olsson97d84ef2019-04-11 11:53:26 +02002 * Copyright 2019 The WebRTC project authors. All Rights Reserved.
Sebastian Jansson9eb38862018-06-14 16:47:42 +02003 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10#include "rtc_base/experiments/field_trial_parser.h"
11
Bjorn Terelius9f00f0e2019-08-30 09:39:31 +020012#include <inttypes.h>
13
Sebastian Jansson9eb38862018-06-14 16:47:42 +020014#include <algorithm>
15#include <map>
16#include <type_traits>
17#include <utility>
18
Sebastian Janssonfea46372018-09-03 10:15:13 +020019#include "rtc_base/checks.h"
Sebastian Jansson9eb38862018-06-14 16:47:42 +020020#include "rtc_base/logging.h"
Bjorn Terelius9f00f0e2019-08-30 09:39:31 +020021#include "rtc_base/numerics/safe_conversions.h"
Sebastian Jansson9eb38862018-06-14 16:47:42 +020022
23namespace webrtc {
24namespace {
25
26int FindOrEnd(std::string str, size_t start, char delimiter) {
27 size_t pos = str.find(delimiter, start);
28 pos = (pos == std::string::npos) ? str.length() : pos;
29 return static_cast<int>(pos);
30}
31} // namespace
32
33FieldTrialParameterInterface::FieldTrialParameterInterface(std::string key)
34 : key_(key) {}
Sebastian Janssonfea46372018-09-03 10:15:13 +020035FieldTrialParameterInterface::~FieldTrialParameterInterface() {
36 RTC_DCHECK(used_) << "Field trial parameter with key: '" << key_
37 << "' never used.";
38}
Sebastian Jansson9eb38862018-06-14 16:47:42 +020039
40void ParseFieldTrial(
41 std::initializer_list<FieldTrialParameterInterface*> fields,
42 std::string trial_string) {
43 std::map<std::string, FieldTrialParameterInterface*> field_map;
Sebastian Janssond69998a2018-12-20 12:25:19 +010044 FieldTrialParameterInterface* keyless_field = nullptr;
Sebastian Jansson9eb38862018-06-14 16:47:42 +020045 for (FieldTrialParameterInterface* field : fields) {
Sebastian Janssonfea46372018-09-03 10:15:13 +020046 field->MarkAsUsed();
Jonas Olsson97d84ef2019-04-11 11:53:26 +020047 if (!field->sub_parameters_.empty()) {
48 for (FieldTrialParameterInterface* sub_field : field->sub_parameters_) {
49 RTC_DCHECK(!sub_field->key_.empty());
50 sub_field->MarkAsUsed();
51 field_map[sub_field->key_] = sub_field;
52 }
53 continue;
54 }
55
56 if (field->key_.empty()) {
Sebastian Janssond69998a2018-12-20 12:25:19 +010057 RTC_DCHECK(!keyless_field);
58 keyless_field = field;
59 } else {
Jonas Olsson97d84ef2019-04-11 11:53:26 +020060 field_map[field->key_] = field;
Sebastian Janssond69998a2018-12-20 12:25:19 +010061 }
Sebastian Jansson9eb38862018-06-14 16:47:42 +020062 }
Jonas Olsson97d84ef2019-04-11 11:53:26 +020063
Sebastian Jansson9eb38862018-06-14 16:47:42 +020064 size_t i = 0;
65 while (i < trial_string.length()) {
66 int val_end = FindOrEnd(trial_string, i, ',');
67 int colon_pos = FindOrEnd(trial_string, i, ':');
68 int key_end = std::min(val_end, colon_pos);
69 int val_begin = key_end + 1;
70 std::string key = trial_string.substr(i, key_end - i);
Danil Chapovalov0a1d1892018-06-21 11:48:25 +020071 absl::optional<std::string> opt_value;
Sebastian Jansson9eb38862018-06-14 16:47:42 +020072 if (val_end >= val_begin)
73 opt_value = trial_string.substr(val_begin, val_end - val_begin);
74 i = val_end + 1;
75 auto field = field_map.find(key);
76 if (field != field_map.end()) {
77 if (!field->second->Parse(std::move(opt_value))) {
78 RTC_LOG(LS_WARNING) << "Failed to read field with key: '" << key
79 << "' in trial: \"" << trial_string << "\"";
80 }
Sebastian Janssond69998a2018-12-20 12:25:19 +010081 } else if (!opt_value && keyless_field && !key.empty()) {
82 if (!keyless_field->Parse(key)) {
83 RTC_LOG(LS_WARNING) << "Failed to read empty key field with value '"
84 << key << "' in trial: \"" << trial_string << "\"";
85 }
Sebastian Jansson9eb38862018-06-14 16:47:42 +020086 } else {
87 RTC_LOG(LS_INFO) << "No field with key: '" << key
88 << "' (found in trial: \"" << trial_string << "\")";
89 }
90 }
Jonas Olsson97d84ef2019-04-11 11:53:26 +020091
92 for (FieldTrialParameterInterface* field : fields) {
93 field->ParseDone();
94 }
Sebastian Jansson9eb38862018-06-14 16:47:42 +020095}
96
97template <>
Danil Chapovalov0a1d1892018-06-21 11:48:25 +020098absl::optional<bool> ParseTypedParameter<bool>(std::string str) {
Sebastian Jansson9eb38862018-06-14 16:47:42 +020099 if (str == "true" || str == "1") {
100 return true;
101 } else if (str == "false" || str == "0") {
102 return false;
103 }
Danil Chapovalov0a1d1892018-06-21 11:48:25 +0200104 return absl::nullopt;
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200105}
106
107template <>
Danil Chapovalov0a1d1892018-06-21 11:48:25 +0200108absl::optional<double> ParseTypedParameter<double>(std::string str) {
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200109 double value;
Sebastian Janssonec764662018-09-03 11:31:26 +0200110 char unit[2]{0, 0};
111 if (sscanf(str.c_str(), "%lf%1s", &value, unit) >= 1) {
112 if (unit[0] == '%')
113 return value / 100;
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200114 return value;
115 } else {
Danil Chapovalov0a1d1892018-06-21 11:48:25 +0200116 return absl::nullopt;
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200117 }
118}
119
120template <>
Danil Chapovalov0a1d1892018-06-21 11:48:25 +0200121absl::optional<int> ParseTypedParameter<int>(std::string str) {
Bjorn Terelius9f00f0e2019-08-30 09:39:31 +0200122 int64_t value;
123 if (sscanf(str.c_str(), "%" SCNd64, &value) == 1) {
124 if (rtc::IsValueInRangeForNumericType<int, int64_t>(value)) {
125 return static_cast<int>(value);
126 }
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200127 }
Bjorn Terelius9f00f0e2019-08-30 09:39:31 +0200128 return absl::nullopt;
129}
130
131template <>
132absl::optional<unsigned> ParseTypedParameter<unsigned>(std::string str) {
133 int64_t value;
134 if (sscanf(str.c_str(), "%" SCNd64, &value) == 1) {
135 if (rtc::IsValueInRangeForNumericType<unsigned, int64_t>(value)) {
136 return static_cast<unsigned>(value);
137 }
138 }
139 return absl::nullopt;
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200140}
141
142template <>
Sebastian Jansson55251c32019-08-08 11:14:51 +0200143absl::optional<absl::optional<bool>> ParseTypedParameter<absl::optional<bool>>(
144 std::string str) {
145 return ParseOptionalParameter<bool>(str);
146}
147template <>
148absl::optional<absl::optional<int>> ParseTypedParameter<absl::optional<int>>(
149 std::string str) {
150 return ParseOptionalParameter<int>(str);
151}
152template <>
Bjorn Terelius9f00f0e2019-08-30 09:39:31 +0200153absl::optional<absl::optional<unsigned>>
154ParseTypedParameter<absl::optional<unsigned>>(std::string str) {
155 return ParseOptionalParameter<unsigned>(str);
156}
157template <>
Sebastian Jansson55251c32019-08-08 11:14:51 +0200158absl::optional<absl::optional<double>>
159ParseTypedParameter<absl::optional<double>>(std::string str) {
160 return ParseOptionalParameter<double>(str);
161}
162
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200163FieldTrialFlag::FieldTrialFlag(std::string key) : FieldTrialFlag(key, false) {}
164
165FieldTrialFlag::FieldTrialFlag(std::string key, bool default_value)
166 : FieldTrialParameterInterface(key), value_(default_value) {}
167
168bool FieldTrialFlag::Get() const {
169 return value_;
170}
171
Sebastian Janssonfea46372018-09-03 10:15:13 +0200172webrtc::FieldTrialFlag::operator bool() const {
173 return value_;
174}
175
Danil Chapovalov0a1d1892018-06-21 11:48:25 +0200176bool FieldTrialFlag::Parse(absl::optional<std::string> str_value) {
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200177 // Only set the flag if there is no argument provided.
178 if (str_value) {
Danil Chapovalov0a1d1892018-06-21 11:48:25 +0200179 absl::optional<bool> opt_value = ParseTypedParameter<bool>(*str_value);
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200180 if (!opt_value)
181 return false;
182 value_ = *opt_value;
183 } else {
184 value_ = true;
185 }
186 return true;
187}
188
Sebastian Jansson2c74d852018-06-26 10:30:16 +0200189AbstractFieldTrialEnum::AbstractFieldTrialEnum(
190 std::string key,
191 int default_value,
192 std::map<std::string, int> mapping)
193 : FieldTrialParameterInterface(key),
194 value_(default_value),
195 enum_mapping_(mapping) {
196 for (auto& key_val : enum_mapping_)
197 valid_values_.insert(key_val.second);
198}
199AbstractFieldTrialEnum::AbstractFieldTrialEnum(const AbstractFieldTrialEnum&) =
200 default;
201AbstractFieldTrialEnum::~AbstractFieldTrialEnum() = default;
202
203bool AbstractFieldTrialEnum::Parse(absl::optional<std::string> str_value) {
204 if (str_value) {
205 auto it = enum_mapping_.find(*str_value);
206 if (it != enum_mapping_.end()) {
207 value_ = it->second;
208 return true;
209 }
210 absl::optional<int> value = ParseTypedParameter<int>(*str_value);
211 if (value.has_value() &&
212 (valid_values_.find(*value) != valid_values_.end())) {
213 value_ = *value;
214 return true;
215 }
216 }
217 return false;
218}
219
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200220template class FieldTrialParameter<bool>;
221template class FieldTrialParameter<double>;
222template class FieldTrialParameter<int>;
Bjorn Terelius9f00f0e2019-08-30 09:39:31 +0200223template class FieldTrialParameter<unsigned>;
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200224
Sebastian Janssonb22f0772018-11-19 17:44:33 +0100225template class FieldTrialConstrained<double>;
226template class FieldTrialConstrained<int>;
Bjorn Terelius9f00f0e2019-08-30 09:39:31 +0200227template class FieldTrialConstrained<unsigned>;
Sebastian Janssonb22f0772018-11-19 17:44:33 +0100228
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200229template class FieldTrialOptional<double>;
230template class FieldTrialOptional<int>;
Bjorn Terelius9f00f0e2019-08-30 09:39:31 +0200231template class FieldTrialOptional<unsigned>;
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200232template class FieldTrialOptional<bool>;
Sebastian Jansson9eb38862018-06-14 16:47:42 +0200233
234} // namespace webrtc