admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use struct parser for rate control trial.

Browse Source 
Bug: webrtc:9883
Change-Id: I9ec7988da2e4d88bedd9b71cae00452f531980d6
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/148581
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Jonas Olsson <jonasolsson@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28856}
This commit is contained in:
Sebastian Jansson 2019-08-14 13:16:26 +02:00 committed by Commit Bot
parent ad9113f191
commit 0ee8008a0d
6 changed files with 265 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
rtc_base/experiments/field_trial_parser.h
View File

@ -243,6 +243,8 @@ absl::optional<bool> ParseTypedParameter<bool>(std::string str);
template <>
absl::optional<double> ParseTypedParameter<double>(std::string str);
template <>
absl::optional<int> ParseTypedParameter<int>(std::string str);
template <>
absl::optional<std::string> ParseTypedParameter<std::string>(std::string str);
template <>

150
rtc_base/experiments/rate_control_settings.cc
View File

@ -16,7 +16,6 @@
#include <string>
#include "api/transport/field_trial_based_config.h"
#include "rtc_base/experiments/field_trial_parser.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/safe_conversions.h"
@ -35,68 +34,76 @@ const char kVp9TrustedRateControllerFieldTrialName[] =
const char* kVideoHysteresisFieldTrialname =
"WebRTC-SimulcastUpswitchHysteresisPercent";
const double kDefaultVideoHysteresisFactor = 1.0;
const char* kScreenshareHysteresisFieldTrialname =
"WebRTC-SimulcastScreenshareUpswitchHysteresisPercent";
// Default to 35% hysteresis for simulcast screenshare.
const double kDefaultScreenshareHysteresisFactor = 1.35;
bool IsEnabled(const WebRtcKeyValueConfig* const key_value_config,
absl::string_view key) {
return key_value_config->Lookup(key).find("Enabled") == 0;
}
double ParseHysteresisFactor(const WebRtcKeyValueConfig* const key_value_config,
absl::string_view key,
double default_value) {
void ParseHysteresisFactor(const WebRtcKeyValueConfig* const key_value_config,
absl::string_view key,
double* output_value) {
std::string group_name = key_value_config->Lookup(key);
int percent = 0;
if (!group_name.empty() && sscanf(group_name.c_str(), "%d", &percent) == 1 &&
percent >= 0) {
return 1.0 + (percent / 100.0);
*output_value = 1.0 + (percent / 100.0);
}
return default_value;
}
} // namespace
constexpr char CongestionWindowConfig::kKey[];
std::unique_ptr<StructParametersParser> CongestionWindowConfig::Parser() {
return StructParametersParser::Create("QueueSize", &queue_size_ms, //
"MinBitrate", &min_bitrate_bps);
}
// static
CongestionWindowConfig CongestionWindowConfig::Parse(absl::string_view config) {
CongestionWindowConfig res;
res.Parser()->Parse(config);
return res;
}
constexpr char VideoRateControlConfig::kKey[];
std::unique_ptr<StructParametersParser> VideoRateControlConfig::Parser() {
// The empty comments ensures that each pair is on a separate line.
return StructParametersParser::Create(
"pacing_factor", &pacing_factor, //
"alr_probing", &alr_probing, //
"vp8_qp_max", &vp8_qp_max, //
"vp8_min_pixels", &vp8_min_pixels, //
"trust_vp8", &trust_vp8, //
"trust_vp9", &trust_vp9, //
"video_hysteresis", &video_hysteresis, //
"screenshare_hysteresis", &screenshare_hysteresis, //
"probe_max_allocation", &probe_max_allocation, //
"bitrate_adjuster", &bitrate_adjuster, //
"adjuster_use_headroom", &adjuster_use_headroom, //
"vp8_s0_boost", &vp8_s0_boost, //
"vp8_dynamic_rate", &vp8_dynamic_rate, //
"vp9_dynamic_rate", &vp9_dynamic_rate);
}
RateControlSettings::RateControlSettings(
const WebRtcKeyValueConfig* const key_value_config)
: congestion_window_("QueueSize"),
congestion_window_pushback_("MinBitrate"),
pacing_factor_("pacing_factor"),
alr_probing_("alr_probing", false),
vp8_qp_max_("vp8_qp_max"),
vp8_min_pixels_("vp8_min_pixels"),
trust_vp8_(
"trust_vp8",
IsEnabled(key_value_config, kVp8TrustedRateControllerFieldTrialName)),
trust_vp9_(
"trust_vp9",
IsEnabled(key_value_config, kVp9TrustedRateControllerFieldTrialName)),
video_hysteresis_("video_hysteresis",
ParseHysteresisFactor(key_value_config,
kVideoHysteresisFieldTrialname,
kDefaultVideoHysteresisFactor)),
screenshare_hysteresis_(
"screenshare_hysteresis",
ParseHysteresisFactor(key_value_config,
kScreenshareHysteresisFieldTrialname,
kDefaultScreenshareHysteresisFactor)),
probe_max_allocation_("probe_max_allocation", true),
bitrate_adjuster_("bitrate_adjuster", false),
adjuster_use_headroom_("adjuster_use_headroom", false),
vp8_s0_boost_("vp8_s0_boost", true),
vp8_dynamic_rate_("vp8_dynamic_rate", false),
vp9_dynamic_rate_("vp9_dynamic_rate", false) {
ParseFieldTrial({&congestion_window_, &congestion_window_pushback_},
key_value_config->Lookup("WebRTC-CongestionWindow"));
ParseFieldTrial(
{&pacing_factor_, &alr_probing_, &vp8_qp_max_, &vp8_min_pixels_,
&trust_vp8_, &trust_vp9_, &video_hysteresis_, &screenshare_hysteresis_,
&probe_max_allocation_, &bitrate_adjuster_, &adjuster_use_headroom_,
&vp8_s0_boost_, &vp8_dynamic_rate_, &vp9_dynamic_rate_},
key_value_config->Lookup("WebRTC-VideoRateControl"));
: congestion_window_config_(CongestionWindowConfig::Parse(
key_value_config->Lookup(CongestionWindowConfig::kKey))) {
video_config_.trust_vp8 =
IsEnabled(key_value_config, kVp8TrustedRateControllerFieldTrialName);
video_config_.trust_vp9 =
IsEnabled(key_value_config, kVp9TrustedRateControllerFieldTrialName);
ParseHysteresisFactor(key_value_config, kVideoHysteresisFieldTrialname,
&video_config_.video_hysteresis);
ParseHysteresisFactor(key_value_config, kScreenshareHysteresisFieldTrialname,
&video_config_.screenshare_hysteresis);
video_config_.Parser()->Parse(
key_value_config->Lookup(VideoRateControlConfig::kKey));
}
RateControlSettings::~RateControlSettings() = default;
@ -115,100 +122,95 @@ RateControlSettings RateControlSettings::ParseFromKeyValueConfig(
}
bool RateControlSettings::UseCongestionWindow() const {
return static_cast<bool>(congestion_window_);
return static_cast<bool>(congestion_window_config_.queue_size_ms);
}
int64_t RateControlSettings::GetCongestionWindowAdditionalTimeMs() const {
return congestion_window_.GetOptional().value_or(kDefaultAcceptedQueueMs);
return congestion_window_config_.queue_size_ms.value_or(
kDefaultAcceptedQueueMs);
}
bool RateControlSettings::UseCongestionWindowPushback() const {
return congestion_window_ && congestion_window_pushback_;
return congestion_window_config_.queue_size_ms &&
congestion_window_config_.min_bitrate_bps;
}
uint32_t RateControlSettings::CongestionWindowMinPushbackTargetBitrateBps()
const {
return congestion_window_pushback_.GetOptional().value_or(
return congestion_window_config_.min_bitrate_bps.value_or(
kDefaultMinPushbackTargetBitrateBps);
}
absl::optional<double> RateControlSettings::GetPacingFactor() const {
return pacing_factor_.GetOptional();
return video_config_.pacing_factor;
}
bool RateControlSettings::UseAlrProbing() const {
return alr_probing_.Get();
return video_config_.alr_probing;
}
absl::optional<int> RateControlSettings::LibvpxVp8QpMax() const {
if (vp8_qp_max_ && (vp8_qp_max_.Value() < 0 || vp8_qp_max_.Value() > 63)) {
if (video_config_.vp8_qp_max &&
(*video_config_.vp8_qp_max < 0 || *video_config_.vp8_qp_max > 63)) {
RTC_LOG(LS_WARNING) << "Unsupported vp8_qp_max_ value, ignored.";
return absl::nullopt;
}
return vp8_qp_max_.GetOptional();
return video_config_.vp8_qp_max;
}
absl::optional<int> RateControlSettings::LibvpxVp8MinPixels() const {
if (vp8_min_pixels_ && vp8_min_pixels_.Value() < 1) {
if (video_config_.vp8_min_pixels && *video_config_.vp8_min_pixels < 1) {
return absl::nullopt;
}
return vp8_min_pixels_.GetOptional();
return video_config_.vp8_min_pixels;
}
bool RateControlSettings::LibvpxVp8TrustedRateController() const {
return trust_vp8_.Get();
return video_config_.trust_vp8;
}
bool RateControlSettings::Vp8BoostBaseLayerQuality() const {
return vp8_s0_boost_.Get();
return video_config_.vp8_s0_boost;
}
bool RateControlSettings::Vp8DynamicRateSettings() const {
return vp8_dynamic_rate_.Get();
return video_config_.vp8_dynamic_rate;
}
bool RateControlSettings::LibvpxVp9TrustedRateController() const {
return trust_vp9_.Get();
return video_config_.trust_vp9;
}
bool RateControlSettings::Vp9DynamicRateSettings() const {
return vp9_dynamic_rate_.Get();
return video_config_.vp9_dynamic_rate;
}
double RateControlSettings::GetSimulcastHysteresisFactor(
VideoCodecMode mode) const {
if (mode == VideoCodecMode::kScreensharing) {
return GetSimulcastScreenshareHysteresisFactor();
return video_config_.screenshare_hysteresis;
}
return GetSimulcastVideoHysteresisFactor();
return video_config_.video_hysteresis;
}
double RateControlSettings::GetSimulcastHysteresisFactor(
VideoEncoderConfig::ContentType content_type) const {
if (content_type == VideoEncoderConfig::ContentType::kScreen) {
return GetSimulcastScreenshareHysteresisFactor();
return video_config_.screenshare_hysteresis;
}
return GetSimulcastVideoHysteresisFactor();
}
double RateControlSettings::GetSimulcastVideoHysteresisFactor() const {
return video_hysteresis_.Get();
}
double RateControlSettings::GetSimulcastScreenshareHysteresisFactor() const {
return screenshare_hysteresis_.Get();
return video_config_.video_hysteresis;
}
bool RateControlSettings::TriggerProbeOnMaxAllocatedBitrateChange() const {
return probe_max_allocation_.Get();
return video_config_.probe_max_allocation;
}
bool RateControlSettings::UseEncoderBitrateAdjuster() const {
return bitrate_adjuster_.Get();
return video_config_.bitrate_adjuster;
}
bool RateControlSettings::BitrateAdjusterCanUseNetworkHeadroom() const {
return adjuster_use_headroom_.Get();
return video_config_.adjuster_use_headroom;
}
} // namespace webrtc

53
rtc_base/experiments/rate_control_settings.h
View File

@ -15,11 +15,39 @@
#include "api/transport/webrtc_key_value_config.h"
#include "api/video_codecs/video_codec.h"
#include "api/video_codecs/video_encoder_config.h"
#include "rtc_base/experiments/field_trial_parser.h"
#include "rtc_base/experiments/field_trial_units.h"
#include "rtc_base/experiments/struct_parameters_parser.h"
namespace webrtc {
struct CongestionWindowConfig {
static constexpr char kKey[] = "WebRTC-CongestionWindow";
absl::optional<int> queue_size_ms;
absl::optional<int> min_bitrate_bps;
std::unique_ptr<StructParametersParser> Parser();
static CongestionWindowConfig Parse(absl::string_view config);
};
struct VideoRateControlConfig {
static constexpr char kKey[] = "WebRTC-VideoRateControl";
absl::optional<double> pacing_factor;
bool alr_probing = false;
absl::optional<int> vp8_qp_max;
absl::optional<int> vp8_min_pixels;
bool trust_vp8 = false;
bool trust_vp9 = false;
double video_hysteresis = 1.0;
// Default to 35% hysteresis for simulcast screenshare.
double screenshare_hysteresis = 1.35;
bool probe_max_allocation = true;
bool bitrate_adjuster = false;
bool adjuster_use_headroom = false;
bool vp8_s0_boost = true;
bool vp8_dynamic_rate = false;
bool vp9_dynamic_rate = false;
std::unique_ptr<StructParametersParser> Parser();
};
class RateControlSettings final {
public:
~RateControlSettings();
@ -62,25 +90,8 @@ class RateControlSettings final {
explicit RateControlSettings(
const WebRtcKeyValueConfig* const key_value_config);
double GetSimulcastVideoHysteresisFactor() const;
double GetSimulcastScreenshareHysteresisFactor() const;
FieldTrialOptional<int> congestion_window_;
FieldTrialOptional<int> congestion_window_pushback_;
FieldTrialOptional<double> pacing_factor_;
FieldTrialParameter<bool> alr_probing_;
FieldTrialOptional<int> vp8_qp_max_;
FieldTrialOptional<int> vp8_min_pixels_;
FieldTrialParameter<bool> trust_vp8_;
FieldTrialParameter<bool> trust_vp9_;
FieldTrialParameter<double> video_hysteresis_;
FieldTrialParameter<double> screenshare_hysteresis_;
FieldTrialParameter<bool> probe_max_allocation_;
FieldTrialParameter<bool> bitrate_adjuster_;
FieldTrialParameter<bool> adjuster_use_headroom_;
FieldTrialParameter<bool> vp8_s0_boost_;
FieldTrialParameter<bool> vp8_dynamic_rate_;
FieldTrialParameter<bool> vp9_dynamic_rate_;
const CongestionWindowConfig congestion_window_config_;
VideoRateControlConfig video_config_;
};
} // namespace webrtc

109
rtc_base/experiments/struct_parameters_parser.cc
View File

@ -9,13 +9,9 @@
*/
#include "rtc_base/experiments/struct_parameters_parser.h"
#include <algorithm>
#include "rtc_base/logging.h"
#include "rtc_base/strings/string_builder.h"
namespace webrtc {
namespace struct_parser_impl {
namespace {
size_t FindOrEnd(absl::string_view str, size_t start, char delimiter) {
size_t pos = str.find(delimiter, start);
@ -24,44 +20,105 @@ size_t FindOrEnd(absl::string_view str, size_t start, char delimiter) {
}
} // namespace
void ParseConfigParams(
absl::string_view config_str,
std::map<std::string, std::function<bool(absl::string_view)>> field_map) {
namespace struct_parser_impl {
namespace {
inline void StringEncode(std::string* target, bool val) {
*target += rtc::ToString(val);
}
inline void StringEncode(std::string* target, double val) {
*target += rtc::ToString(val);
}
inline void StringEncode(std::string* target, int val) {
*target += rtc::ToString(val);
}
inline void StringEncode(std::string* target, DataRate val) {
*target += webrtc::ToString(val);
}
inline void StringEncode(std::string* target, DataSize val) {
*target += webrtc::ToString(val);
}
inline void StringEncode(std::string* target, TimeDelta val) {
*target += webrtc::ToString(val);
}
template <typename T>
inline void StringEncode(std::string* sb, absl::optional<T> val) {
if (val)
StringEncode(sb, *val);
}
} // namespace
template <typename T>
bool TypedParser<T>::Parse(absl::string_view src, void* target) {
auto parsed = ParseTypedParameter<T>(std::string(src));
if (parsed.has_value())
*reinterpret_cast<T*>(target) = *parsed;
return parsed.has_value();
}
template <typename T>
void TypedParser<T>::Encode(const void* src, std::string* target) {
StringEncode(target, *reinterpret_cast<const T*>(src));
}
template class TypedParser<bool>;
template class TypedParser<double>;
template class TypedParser<int>;
template class TypedParser<absl::optional<double>>;
template class TypedParser<absl::optional<int>>;
template class TypedParser<DataRate>;
template class TypedParser<DataSize>;
template class TypedParser<TimeDelta>;
template class TypedParser<absl::optional<DataRate>>;
template class TypedParser<absl::optional<DataSize>>;
template class TypedParser<absl::optional<TimeDelta>>;
} // namespace struct_parser_impl
StructParametersParser::StructParametersParser(
std::vector<struct_parser_impl::MemberParameter> members)
: members_(std::move(members)) {}
void StructParametersParser::Parse(absl::string_view src) {
size_t i = 0;
while (i < config_str.length()) {
size_t val_end = FindOrEnd(config_str, i, ',');
size_t colon_pos = FindOrEnd(config_str, i, ':');
while (i < src.length()) {
size_t val_end = FindOrEnd(src, i, ',');
size_t colon_pos = FindOrEnd(src, i, ':');
size_t key_end = std::min(val_end, colon_pos);
size_t val_begin = key_end + 1u;
std::string key(config_str.substr(i, key_end - i));
absl::string_view key(src.substr(i, key_end - i));
absl::string_view opt_value;
if (val_end >= val_begin)
opt_value = config_str.substr(val_begin, val_end - val_begin);
opt_value = src.substr(val_begin, val_end - val_begin);
i = val_end + 1u;
auto field = field_map.find(key);
if (field != field_map.end()) {
if (!field->second(opt_value)) {
RTC_LOG(LS_WARNING) << "Failed to read field with key: '" << key
<< "' in trial: \"" << config_str << "\"";
bool found = false;
for (auto& member : members_) {
if (key == member.key) {
found = true;
if (!member.parser.parse(opt_value, member.member_ptr)) {
RTC_LOG(LS_WARNING) << "Failed to read field with key: '" << key
<< "' in trial: \"" << src << "\"";
}
break;
}
} else {
}
if (!found) {
RTC_LOG(LS_INFO) << "No field with key: '" << key
<< "' (found in trial: \"" << config_str << "\")";
<< "' (found in trial: \"" << src << "\")";
}
}
}
std::string EncodeStringStringMap(std::map<std::string, std::string> mapping) {
rtc::StringBuilder sb;
std::string StructParametersParser::Encode() const {
std::string res;
bool first = true;
for (const auto& kv : mapping) {
for (const auto& member : members_) {
if (!first)
sb << ",";
sb << kv.first << ":" << kv.second;
res += ",";
res += member.key;
res += ":";
member.parser.encode(member.member_ptr, &res);
first = false;
}
return sb.Release();
return res;
}
} // namespace struct_parser_impl
} // namespace webrtc

222
rtc_base/experiments/struct_parameters_parser.h
View File

@ -26,189 +26,83 @@
namespace webrtc {
namespace struct_parser_impl {
inline std::string StringEncode(bool val) {
return rtc::ToString(val);
}
inline std::string StringEncode(double val) {
return rtc::ToString(val);
}
inline std::string StringEncode(int val) {
return rtc::ToString(val);
}
inline std::string StringEncode(std::string val) {
return val;
}
inline std::string StringEncode(DataRate val) {
return ToString(val);
}
inline std::string StringEncode(DataSize val) {
return ToString(val);
}
inline std::string StringEncode(TimeDelta val) {
return ToString(val);
}
struct TypedMemberParser {
public:
bool (*parse)(const absl::string_view src, void* target);
void (*encode)(const void* src, std::string* target);
};
struct MemberParameter {
const char* key;
void* member_ptr;
TypedMemberParser parser;
};
template <typename T>
inline std::string StringEncode(absl::optional<T> val) {
if (val)
return StringEncode(*val);
return "";
}
class TypedParser {
public:
static bool Parse(absl::string_view src, void* target);
static void Encode(const void* src, std::string* target);
};
// Instantiated in cc file to avoid duplication during compile. Add additional
// parsers as needed. Generally, try to use these suggested types even if the
// context where the value is used might require a different type. For instance,
// a size_t representing a packet size should use an int parameter as there's no
// need to support packet sizes larger than INT32_MAX.
extern template class TypedParser<bool>;
extern template class TypedParser<double>;
extern template class TypedParser<int>;
extern template class TypedParser<absl::optional<double>>;
extern template class TypedParser<absl::optional<int>>;
extern template class TypedParser<DataRate>;
extern template class TypedParser<DataSize>;
extern template class TypedParser<TimeDelta>;
extern template class TypedParser<absl::optional<DataRate>>;
extern template class TypedParser<absl::optional<DataSize>>;
extern template class TypedParser<absl::optional<TimeDelta>>;
template <typename T>
struct LambdaTraits : public LambdaTraits<decltype(&T::operator())> {};
template <typename ClassType, typename RetType, typename SourceType>
struct LambdaTraits<RetType* (ClassType::*)(SourceType*)const> {
using ret = RetType;
using src = SourceType;
};
void ParseConfigParams(
absl::string_view config_str,
std::map<std::string, std::function<bool(absl::string_view)>> field_map);
std::string EncodeStringStringMap(std::map<std::string, std::string> mapping);
template <typename StructType>
class StructParameterParser {
public:
virtual bool Parse(absl::string_view src, StructType* target) const = 0;
virtual bool Changed(const StructType& src, const StructType& base) const = 0;
virtual std::string Encode(const StructType& src) const = 0;
virtual ~StructParameterParser() = default;
};
template <typename StructType, typename T>
class StructParameterImpl : public StructParameterParser<StructType> {
public:
explicit StructParameterImpl(std::function<T*(StructType*)> field_getter)
: field_getter_(std::move(field_getter)) {}
bool Parse(absl::string_view src, StructType* target) const override {
auto parsed = ParseTypedParameter<T>(std::string(src));
if (parsed.has_value())
*field_getter_(target) = *parsed;
return parsed.has_value();
}
bool Changed(const StructType& src, const StructType& base) const override {
T base_value = *field_getter_(const_cast<StructType*>(&base));
T value = *field_getter_(const_cast<StructType*>(&src));
return value != base_value;
}
std::string Encode(const StructType& src) const override {
T value = *field_getter_(const_cast<StructType*>(&src));
return struct_parser_impl::StringEncode(value);
}
private:
const std::function<T*(StructType*)> field_getter_;
};
template <typename StructType>
struct StructParameter {
std::string key;
StructParameterParser<StructType>* parser;
};
template <typename S,
typename Closure,
typename T = typename LambdaTraits<Closure>::ret>
void AddParameters(std::vector<StructParameter<S>>* out,
std::string key,
Closure getter) {
auto* parser = new StructParameterImpl<S, T>(getter);
out->push_back(StructParameter<S>{std::move(key), parser});
void AddMembers(MemberParameter* out, const char* key, T* member) {
*out = MemberParameter{
key, member,
TypedMemberParser{&TypedParser<T>::Parse, &TypedParser<T>::Encode}};
}
template <typename S,
typename Closure,
typename T = typename LambdaTraits<Closure>::ret,
typename... Args>
void AddParameters(std::vector<StructParameter<S>>* out,
std::string key,
Closure getter,
Args... args) {
AddParameters(out, key, getter);
AddParameters<S>(out, args...);
template <typename T, typename... Args>
void AddMembers(MemberParameter* out,
const char* key,
T* member,
Args... args) {
AddMembers(out, key, member);
AddMembers(++out, args...);
}
} // namespace struct_parser_impl
template <typename StructType>
class StructParametersParser {
public:
~StructParametersParser() {
for (auto& param : parameters_) {
delete param.parser;
}
template <typename T, typename... Args>
static std::unique_ptr<StructParametersParser> Create(const char* first_key,
T* first_member,
Args... args) {
std::vector<struct_parser_impl::MemberParameter> members(
sizeof...(args) / 2 + 1);
struct_parser_impl::AddMembers(&members.front(), std::move(first_key),
first_member, args...);
return absl::WrapUnique(new StructParametersParser(std::move(members)));
}
void Parse(StructType* target, absl::string_view src) {
std::map<std::string, std::function<bool(absl::string_view)>> field_parsers;
for (const auto& param : parameters_) {
field_parsers.emplace(param.key, [target, param](absl::string_view src) {
return param.parser->Parse(src, target);
});
}
struct_parser_impl::ParseConfigParams(src, std::move(field_parsers));
}
StructType Parse(absl::string_view src) {
StructType res;
Parse(&res, src);
return res;
}
std::string EncodeChanged(const StructType& src) {
static StructType base;
std::map<std::string, std::string> pairs;
for (const auto& param : parameters_) {
if (param.parser->Changed(src, base))
pairs[param.key] = param.parser->Encode(src);
}
return struct_parser_impl::EncodeStringStringMap(pairs);
}
std::string EncodeAll(const StructType& src) {
std::map<std::string, std::string> pairs;
for (const auto& param : parameters_) {
pairs[param.key] = param.parser->Encode(src);
}
return struct_parser_impl::EncodeStringStringMap(pairs);
}
void Parse(absl::string_view src);
std::string Encode() const;
private:
template <typename C, typename S, typename... Args>
friend std::unique_ptr<StructParametersParser<S>>
CreateStructParametersParser(std::string, C, Args...);
explicit StructParametersParser(
std::vector<struct_parser_impl::StructParameter<StructType>> parameters)
: parameters_(parameters) {}
std::vector<struct_parser_impl::MemberParameter> members);
std::vector<struct_parser_impl::StructParameter<StructType>> parameters_;
std::vector<struct_parser_impl::MemberParameter> members_;
};
// Creates a struct parameters parser based on interleaved key and field
// accessor arguments, where the field accessor converts a struct pointer to a
// member pointer: FieldType*(StructType*). See the unit tests for example
// usage. Note that the struct type is inferred from the field getters. Beware
// of providing incorrect arguments to this, such as mixing the struct type or
// incorrect return values, as this will cause very confusing compile errors.
template <typename Closure,
typename S = typename struct_parser_impl::LambdaTraits<Closure>::src,
typename... Args>
std::unique_ptr<StructParametersParser<S>> CreateStructParametersParser(
std::string first_key,
Closure first_getter,
Args... args) {
std::vector<struct_parser_impl::StructParameter<S>> parameters;
struct_parser_impl::AddParameters<S>(&parameters, std::move(first_key),
first_getter, args...);
// absl::make_unique can't be used since the StructParametersParser
// constructor is only visible to this create function.
return absl::WrapUnique(new StructParametersParser<S>(std::move(parameters)));
}
} // namespace webrtc
#endif // RTC_BASE_EXPERIMENTS_STRUCT_PARAMETERS_PARSER_H_

49
rtc_base/experiments/struct_parameters_parser_unittest.cc
View File

@ -17,30 +17,25 @@ struct DummyConfig {
double factor = 0.5;
int retries = 5;
bool ping = 0;
std::string hash = "a80";
absl::optional<TimeDelta> duration;
absl::optional<TimeDelta> latency = TimeDelta::ms(100);
static StructParametersParser<DummyConfig>* Parser();
std::unique_ptr<StructParametersParser> Parser();
};
StructParametersParser<DummyConfig>* DummyConfig::Parser() {
using C = DummyConfig;
std::unique_ptr<StructParametersParser> DummyConfig::Parser() {
// The empty comments ensures that each pair is on a separate line.
static auto parser = CreateStructParametersParser(
"e", [](C* c) { return &c->enabled; }, //
"f", [](C* c) { return &c->factor; }, //
"r", [](C* c) { return &c->retries; }, //
"p", [](C* c) { return &c->ping; }, //
"h", [](C* c) { return &c->hash; }, //
"d", [](C* c) { return &c->duration; }, //
"l", [](C* c) { return &c->latency; }); //
return parser.get();
return StructParametersParser::Create("e", &enabled, //
"f", &factor, //
"r", &retries, //
"p", &ping, //
"d", &duration, //
"l", &latency);
}
} // namespace
TEST(StructParametersParserTest, ParsesValidParameters) {
DummyConfig exp =
DummyConfig::Parser()->Parse("e:1,f:-1.7,r:2,p:1,h:x7c,d:8,l:,");
DummyConfig exp;
exp.Parser()->Parse("e:1,f:-1.7,r:2,p:1,d:8,l:,");
EXPECT_TRUE(exp.enabled);
EXPECT_EQ(exp.factor, -1.7);
EXPECT_EQ(exp.retries, 2);
@ -50,35 +45,19 @@ TEST(StructParametersParserTest, ParsesValidParameters) {
}
TEST(StructParametersParserTest, UsesDefaults) {
DummyConfig exp = DummyConfig::Parser()->Parse("");
DummyConfig exp;
exp.Parser()->Parse("");
EXPECT_FALSE(exp.enabled);
EXPECT_EQ(exp.factor, 0.5);
EXPECT_EQ(exp.retries, 5);
EXPECT_EQ(exp.ping, false);
EXPECT_EQ(exp.hash, "a80");
}
TEST(StructParametersParserTest, EmptyDefaults) {
DummyConfig exp;
auto encoded = DummyConfig::Parser()->EncodeChanged(exp);
// Unchanged parameters are not encoded.
EXPECT_EQ(encoded, "");
}
TEST(StructParametersParserTest, EncodeAll) {
DummyConfig exp;
auto encoded = DummyConfig::Parser()->EncodeAll(exp);
auto encoded = exp.Parser()->Encode();
// All parameters are encoded.
EXPECT_EQ(encoded, "d:,e:false,f:0.5,h:a80,l:100 ms,p:false,r:5");
}
TEST(StructParametersParserTest, EncodeChanged) {
DummyConfig exp;
exp.ping = true;
exp.retries = 4;
auto encoded = DummyConfig::Parser()->EncodeChanged(exp);
// We expect the changed parameters to be encoded in alphabetical order.
EXPECT_EQ(encoded, "p:true,r:4");
EXPECT_EQ(encoded, "e:false,f:0.5,r:5,p:false,d:,l:100 ms");
}
} // namespace webrtc