Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 1 | /* |
Jonas Olsson | 97d84ef | 2019-04-11 11:53:26 +0200 | [diff] [blame] | 2 | * Copyright 2019 The WebRTC project authors. All Rights Reserved. |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 3 | * |
| 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 Terelius | 9f00f0e | 2019-08-30 09:39:31 +0200 | [diff] [blame] | 12 | #include <inttypes.h> |
| 13 | |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 14 | #include <algorithm> |
| 15 | #include <map> |
| 16 | #include <type_traits> |
| 17 | #include <utility> |
| 18 | |
Sebastian Jansson | fea4637 | 2018-09-03 10:15:13 +0200 | [diff] [blame] | 19 | #include "rtc_base/checks.h" |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 20 | #include "rtc_base/logging.h" |
Bjorn Terelius | 9f00f0e | 2019-08-30 09:39:31 +0200 | [diff] [blame] | 21 | #include "rtc_base/numerics/safe_conversions.h" |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 22 | |
| 23 | namespace webrtc { |
| 24 | namespace { |
| 25 | |
| 26 | int 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 | |
| 33 | FieldTrialParameterInterface::FieldTrialParameterInterface(std::string key) |
| 34 | : key_(key) {} |
Sebastian Jansson | fea4637 | 2018-09-03 10:15:13 +0200 | [diff] [blame] | 35 | FieldTrialParameterInterface::~FieldTrialParameterInterface() { |
| 36 | RTC_DCHECK(used_) << "Field trial parameter with key: '" << key_ |
| 37 | << "' never used."; |
| 38 | } |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 39 | |
| 40 | void ParseFieldTrial( |
| 41 | std::initializer_list<FieldTrialParameterInterface*> fields, |
| 42 | std::string trial_string) { |
| 43 | std::map<std::string, FieldTrialParameterInterface*> field_map; |
Sebastian Jansson | d69998a | 2018-12-20 12:25:19 +0100 | [diff] [blame] | 44 | FieldTrialParameterInterface* keyless_field = nullptr; |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 45 | for (FieldTrialParameterInterface* field : fields) { |
Sebastian Jansson | fea4637 | 2018-09-03 10:15:13 +0200 | [diff] [blame] | 46 | field->MarkAsUsed(); |
Jonas Olsson | 97d84ef | 2019-04-11 11:53:26 +0200 | [diff] [blame] | 47 | 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 Jansson | d69998a | 2018-12-20 12:25:19 +0100 | [diff] [blame] | 57 | RTC_DCHECK(!keyless_field); |
| 58 | keyless_field = field; |
| 59 | } else { |
Jonas Olsson | 97d84ef | 2019-04-11 11:53:26 +0200 | [diff] [blame] | 60 | field_map[field->key_] = field; |
Sebastian Jansson | d69998a | 2018-12-20 12:25:19 +0100 | [diff] [blame] | 61 | } |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 62 | } |
Jonas Olsson | 97d84ef | 2019-04-11 11:53:26 +0200 | [diff] [blame] | 63 | |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 64 | 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 Chapovalov | 0a1d189 | 2018-06-21 11:48:25 +0200 | [diff] [blame] | 71 | absl::optional<std::string> opt_value; |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 72 | 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 Jansson | d69998a | 2018-12-20 12:25:19 +0100 | [diff] [blame] | 81 | } 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 Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 86 | } else { |
| 87 | RTC_LOG(LS_INFO) << "No field with key: '" << key |
| 88 | << "' (found in trial: \"" << trial_string << "\")"; |
| 89 | } |
| 90 | } |
Jonas Olsson | 97d84ef | 2019-04-11 11:53:26 +0200 | [diff] [blame] | 91 | |
| 92 | for (FieldTrialParameterInterface* field : fields) { |
| 93 | field->ParseDone(); |
| 94 | } |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 95 | } |
| 96 | |
| 97 | template <> |
Danil Chapovalov | 0a1d189 | 2018-06-21 11:48:25 +0200 | [diff] [blame] | 98 | absl::optional<bool> ParseTypedParameter<bool>(std::string str) { |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 99 | if (str == "true" || str == "1") { |
| 100 | return true; |
| 101 | } else if (str == "false" || str == "0") { |
| 102 | return false; |
| 103 | } |
Danil Chapovalov | 0a1d189 | 2018-06-21 11:48:25 +0200 | [diff] [blame] | 104 | return absl::nullopt; |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | template <> |
Danil Chapovalov | 0a1d189 | 2018-06-21 11:48:25 +0200 | [diff] [blame] | 108 | absl::optional<double> ParseTypedParameter<double>(std::string str) { |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 109 | double value; |
Sebastian Jansson | ec76466 | 2018-09-03 11:31:26 +0200 | [diff] [blame] | 110 | 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 Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 114 | return value; |
| 115 | } else { |
Danil Chapovalov | 0a1d189 | 2018-06-21 11:48:25 +0200 | [diff] [blame] | 116 | return absl::nullopt; |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 117 | } |
| 118 | } |
| 119 | |
| 120 | template <> |
Danil Chapovalov | 0a1d189 | 2018-06-21 11:48:25 +0200 | [diff] [blame] | 121 | absl::optional<int> ParseTypedParameter<int>(std::string str) { |
Bjorn Terelius | 9f00f0e | 2019-08-30 09:39:31 +0200 | [diff] [blame] | 122 | 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 Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 127 | } |
Bjorn Terelius | 9f00f0e | 2019-08-30 09:39:31 +0200 | [diff] [blame] | 128 | return absl::nullopt; |
| 129 | } |
| 130 | |
| 131 | template <> |
| 132 | absl::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 Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 140 | } |
| 141 | |
| 142 | template <> |
Sebastian Jansson | 55251c3 | 2019-08-08 11:14:51 +0200 | [diff] [blame] | 143 | absl::optional<absl::optional<bool>> ParseTypedParameter<absl::optional<bool>>( |
| 144 | std::string str) { |
| 145 | return ParseOptionalParameter<bool>(str); |
| 146 | } |
| 147 | template <> |
| 148 | absl::optional<absl::optional<int>> ParseTypedParameter<absl::optional<int>>( |
| 149 | std::string str) { |
| 150 | return ParseOptionalParameter<int>(str); |
| 151 | } |
| 152 | template <> |
Bjorn Terelius | 9f00f0e | 2019-08-30 09:39:31 +0200 | [diff] [blame] | 153 | absl::optional<absl::optional<unsigned>> |
| 154 | ParseTypedParameter<absl::optional<unsigned>>(std::string str) { |
| 155 | return ParseOptionalParameter<unsigned>(str); |
| 156 | } |
| 157 | template <> |
Sebastian Jansson | 55251c3 | 2019-08-08 11:14:51 +0200 | [diff] [blame] | 158 | absl::optional<absl::optional<double>> |
| 159 | ParseTypedParameter<absl::optional<double>>(std::string str) { |
| 160 | return ParseOptionalParameter<double>(str); |
| 161 | } |
| 162 | |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 163 | FieldTrialFlag::FieldTrialFlag(std::string key) : FieldTrialFlag(key, false) {} |
| 164 | |
| 165 | FieldTrialFlag::FieldTrialFlag(std::string key, bool default_value) |
| 166 | : FieldTrialParameterInterface(key), value_(default_value) {} |
| 167 | |
| 168 | bool FieldTrialFlag::Get() const { |
| 169 | return value_; |
| 170 | } |
| 171 | |
Sebastian Jansson | fea4637 | 2018-09-03 10:15:13 +0200 | [diff] [blame] | 172 | webrtc::FieldTrialFlag::operator bool() const { |
| 173 | return value_; |
| 174 | } |
| 175 | |
Danil Chapovalov | 0a1d189 | 2018-06-21 11:48:25 +0200 | [diff] [blame] | 176 | bool FieldTrialFlag::Parse(absl::optional<std::string> str_value) { |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 177 | // Only set the flag if there is no argument provided. |
| 178 | if (str_value) { |
Danil Chapovalov | 0a1d189 | 2018-06-21 11:48:25 +0200 | [diff] [blame] | 179 | absl::optional<bool> opt_value = ParseTypedParameter<bool>(*str_value); |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 180 | if (!opt_value) |
| 181 | return false; |
| 182 | value_ = *opt_value; |
| 183 | } else { |
| 184 | value_ = true; |
| 185 | } |
| 186 | return true; |
| 187 | } |
| 188 | |
Sebastian Jansson | 2c74d85 | 2018-06-26 10:30:16 +0200 | [diff] [blame] | 189 | AbstractFieldTrialEnum::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 | } |
| 199 | AbstractFieldTrialEnum::AbstractFieldTrialEnum(const AbstractFieldTrialEnum&) = |
| 200 | default; |
| 201 | AbstractFieldTrialEnum::~AbstractFieldTrialEnum() = default; |
| 202 | |
| 203 | bool 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 Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 220 | template class FieldTrialParameter<bool>; |
| 221 | template class FieldTrialParameter<double>; |
| 222 | template class FieldTrialParameter<int>; |
Bjorn Terelius | 9f00f0e | 2019-08-30 09:39:31 +0200 | [diff] [blame] | 223 | template class FieldTrialParameter<unsigned>; |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 224 | |
Sebastian Jansson | b22f077 | 2018-11-19 17:44:33 +0100 | [diff] [blame] | 225 | template class FieldTrialConstrained<double>; |
| 226 | template class FieldTrialConstrained<int>; |
Bjorn Terelius | 9f00f0e | 2019-08-30 09:39:31 +0200 | [diff] [blame] | 227 | template class FieldTrialConstrained<unsigned>; |
Sebastian Jansson | b22f077 | 2018-11-19 17:44:33 +0100 | [diff] [blame] | 228 | |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 229 | template class FieldTrialOptional<double>; |
| 230 | template class FieldTrialOptional<int>; |
Bjorn Terelius | 9f00f0e | 2019-08-30 09:39:31 +0200 | [diff] [blame] | 231 | template class FieldTrialOptional<unsigned>; |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 232 | template class FieldTrialOptional<bool>; |
Sebastian Jansson | 9eb3886 | 2018-06-14 16:47:42 +0200 | [diff] [blame] | 233 | |
| 234 | } // namespace webrtc |