Use struct parser for rate control trial.
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}
diff --git a/rtc_base/experiments/field_trial_parser.h b/rtc_base/experiments/field_trial_parser.h
index 3c3731c..997a7fd 100644
--- a/rtc_base/experiments/field_trial_parser.h
+++ b/rtc_base/experiments/field_trial_parser.h
@@ -243,6 +243,8 @@
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 <>
diff --git a/rtc_base/experiments/rate_control_settings.cc b/rtc_base/experiments/rate_control_settings.cc
index 69e685a..b82a981 100644
--- a/rtc_base/experiments/rate_control_settings.cc
+++ b/rtc_base/experiments/rate_control_settings.cc
@@ -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* 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 @@
}
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
diff --git a/rtc_base/experiments/rate_control_settings.h b/rtc_base/experiments/rate_control_settings.h
index b003bee..0781205d 100644
--- a/rtc_base/experiments/rate_control_settings.h
+++ b/rtc_base/experiments/rate_control_settings.h
@@ -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 @@
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
diff --git a/rtc_base/experiments/struct_parameters_parser.cc b/rtc_base/experiments/struct_parameters_parser.cc
index cef9386..24058b5 100644
--- a/rtc_base/experiments/struct_parameters_parser.cc
+++ b/rtc_base/experiments/struct_parameters_parser.cc
@@ -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 @@
}
} // 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
diff --git a/rtc_base/experiments/struct_parameters_parser.h b/rtc_base/experiments/struct_parameters_parser.h
index f6728f6..b40f381 100644
--- a/rtc_base/experiments/struct_parameters_parser.h
+++ b/rtc_base/experiments/struct_parameters_parser.h
@@ -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>(¶meters, 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_
diff --git a/rtc_base/experiments/struct_parameters_parser_unittest.cc b/rtc_base/experiments/struct_parameters_parser_unittest.cc
index 1e88f8c..69103bd 100644
--- a/rtc_base/experiments/struct_parameters_parser_unittest.cc
+++ b/rtc_base/experiments/struct_parameters_parser_unittest.cc
@@ -17,30 +17,25 @@
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, 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
