hps: fixing parsing hps config parameters.
(1) Add different default filters for HpsSense and HpsNotify.
(2) prefix each parameter with feature_name QuickDim or
SnoopingProtection.
(3) Only require expected parameters are provided while allowing extra
parameters to be set to be more consistent for QuickDim.
(4) Unit tests are fixed.
(5) AboutFlags are also fixed.
TEST='verified on vm'
BUG=b:219486878
Change-Id: I5c0ac5401d37715d60dd9f32b19c72953607aa80
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3459378
Reviewed-by: Michael Martis <martis@chromium.org>
Reviewed-by: Alex Newcomer <newcomer@chromium.org>
Commit-Queue: Guoxing Zhao <charleszhao@chromium.org>
Cr-Commit-Position: refs/heads/main@{#971672}
diff --git a/ash/system/hps/hps_configuration.cc b/ash/system/hps/hps_configuration.cc
index ab459cbf..eca3c85 100644
--- a/ash/system/hps/hps_configuration.cc
+++ b/ash/system/hps/hps_configuration.cc
@@ -5,7 +5,9 @@
#include "ash/system/hps/hps_configuration.h"
#include "ash/constants/ash_features.h"
+#include "base/logging.h"
#include "base/metrics/field_trial_params.h"
+#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "base/time/time.h"
#include "chromeos/dbus/hps/hps_service.pb.h"
@@ -28,8 +30,11 @@
// Returns either the integer parameter with the given name, or nullopt if the
// parameter can't be found or parsed.
absl::optional<int> GetIntParam(const base::FieldTrialParams& params,
- const std::string& name) {
- const auto it = params.find(name);
+ const std::string& feature_name,
+ const std::string& param_name) {
+ const std::string full_param_name =
+ base::StrCat({feature_name, "_", param_name});
+ const auto it = params.find(full_param_name);
if (it == params.end())
return absl::nullopt;
@@ -40,48 +45,34 @@
return result;
}
-// Returns either the boolean parameter with the given name, or nullopt if the
-// parameter can't be found or parsed.
-absl::optional<bool> GetBoolParam(const base::FieldTrialParams& params,
- const std::string& name) {
- const auto it = params.find(name);
- if (it == params.end())
- return absl::nullopt;
-
- if (it->second == "true") {
- return true;
- } else if (it->second == "false") {
- return false;
- } else {
- return absl::nullopt;
- }
-}
-
// The config to use when no parameters are specified. We need to ensure that
// that empty params induce a working config (as required for, e.g., a
// chrome:://flags entry).
-hps::FeatureConfig GetDefaultFeatureConfig() {
+hps::FeatureConfig GetDefaultHpsNotifyFeatureConfig() {
hps::FeatureConfig config;
auto& filter_config = *config.mutable_average_filter_config();
filter_config.set_average_window_size(3);
- filter_config.set_positive_score_threshold(40);
- filter_config.set_negative_score_threshold(-40);
- filter_config.set_default_uncertain_score(0);
+ filter_config.set_positive_score_threshold(-30);
+ filter_config.set_negative_score_threshold(-30);
+ filter_config.set_default_uncertain_score(-128);
return config;
}
-// Returns true if the given set of keys is the entire set of keys in the params
-// map.
-bool ParamKeysAre(const base::FieldTrialParams& params,
- const std::set<std::string> keys) {
- for (const std::string& key : keys) {
- if (params.find(key) == params.end())
- return false;
- }
-
- return params.size() == keys.size();
+hps::FeatureConfig GetDefaultHpsSenseFeatureConfig() {
+ hps::FeatureConfig config;
+ auto& filter_config = *config.mutable_consecutive_results_filter_config();
+ // Any positive result will undim the screen.
+ filter_config.set_positive_count_threshold(1);
+ // Only dim if at least two consecutive negative result.
+ filter_config.set_negative_count_threshold(2);
+ // UNKNOWN will not undim, but it will block quick dim, so it should also be
+ // fired with confidence.
+ filter_config.set_uncertain_count_threshold(2);
+ filter_config.set_positive_score_threshold(0);
+ filter_config.set_negative_score_threshold(0);
+ return config;
}
// This function constructs a FeatureConfig proto from feature parameters..
@@ -93,70 +84,84 @@
// More details can be found at:
// src/platform2/hps/daemon/filters/filter_factory.h
absl::optional<hps::FeatureConfig> ConstructHpsFilterConfigFromFeatureParams(
- const base::Feature& feature) {
+ const base::Feature& feature,
+ const hps::FeatureConfig& default_value) {
// Load current params map for the feature.
base::FieldTrialParams params;
base::GetFieldTrialParamsByFeature(feature, ¶ms);
- // Valid default case.
- if (params.empty())
- return GetDefaultFeatureConfig();
+ // Returns default if no params is set.
+ if (params.empty()) {
+ return default_value;
+ }
+
+ const std::string& feature_name = feature.name;
const absl::optional<int> filter_config_case =
- GetIntParam(params, "filter_config_case");
- if (!filter_config_case.has_value())
+ GetIntParam(params, feature_name, "filter_config_case");
+ if (!filter_config_case.has_value()) {
+ LOG(ERROR) << "HpsFilterConfig error: missing param filter_config_case for "
+ << feature_name;
return absl::nullopt;
+ }
switch (*filter_config_case) {
case hps::FeatureConfig::kBasicFilterConfig: {
- // There are no parameters for the basic filter.
- if (!ParamKeysAre(params, {"filter_config_case"}))
- return absl::nullopt;
-
hps::FeatureConfig config;
config.mutable_basic_filter_config();
return config;
}
case hps::FeatureConfig::kConsecutiveResultsFilterConfig: {
- const absl::optional<int> count = GetIntParam(params, "count");
- const absl::optional<int> threshold = GetIntParam(params, "threshold");
- const absl::optional<bool> initial_state =
- GetBoolParam(params, "initial_state");
+ const absl::optional<int> positive_count_threshold =
+ GetIntParam(params, feature_name, "positive_count_threshold");
+ const absl::optional<int> negative_count_threshold =
+ GetIntParam(params, feature_name, "negative_count_threshold");
+ const absl::optional<int> uncertain_count_threshold =
+ GetIntParam(params, feature_name, "uncertain_count_threshold");
+ const absl::optional<int> positive_score_threshold =
+ GetIntParam(params, feature_name, "positive_score_threshold");
+ const absl::optional<int> negative_score_threshold =
+ GetIntParam(params, feature_name, "negative_score_threshold");
- if (!count.has_value() || !threshold.has_value() ||
- !initial_state.has_value() ||
- !ParamKeysAre(params, {"filter_config_case", "count", "threshold",
- "initial_state"})) {
+ if (!positive_count_threshold.has_value() ||
+ !negative_count_threshold.has_value() ||
+ !uncertain_count_threshold.has_value() ||
+ !positive_score_threshold.has_value() ||
+ !negative_score_threshold.has_value()) {
+ LOG(ERROR) << "HpsFilterConfig error: missing params for "
+ "ConsecutiveResultsFilterConfig for "
+ << feature_name;
return absl::nullopt;
}
hps::FeatureConfig config;
auto& filter_config = *config.mutable_consecutive_results_filter_config();
- filter_config.set_count(*count);
- filter_config.set_threshold(*threshold);
- filter_config.set_initial_state(*initial_state);
+ filter_config.set_positive_count_threshold(*positive_count_threshold);
+ filter_config.set_negative_count_threshold(*negative_count_threshold);
+ filter_config.set_uncertain_count_threshold(*uncertain_count_threshold);
+ filter_config.set_positive_score_threshold(*positive_score_threshold);
+ filter_config.set_negative_score_threshold(*negative_score_threshold);
return config;
}
case hps::FeatureConfig::kAverageFilterConfig: {
const absl::optional<int> average_window_size =
- GetIntParam(params, "average_window_size");
+ GetIntParam(params, feature_name, "average_window_size");
const absl::optional<int> positive_score_threshold =
- GetIntParam(params, "positive_score_threshold");
+ GetIntParam(params, feature_name, "positive_score_threshold");
const absl::optional<int> negative_score_threshold =
- GetIntParam(params, "negative_score_threshold");
+ GetIntParam(params, feature_name, "negative_score_threshold");
const absl::optional<int> default_uncertain_score =
- GetIntParam(params, "default_uncertain_score");
+ GetIntParam(params, feature_name, "default_uncertain_score");
if (!average_window_size.has_value() ||
!positive_score_threshold.has_value() ||
!negative_score_threshold.has_value() ||
- !default_uncertain_score.has_value() ||
- !ParamKeysAre(params,
- {"filter_config_case", "average_window_size",
- "positive_score_threshold", "negative_score_threshold",
- "default_uncertain_score"})) {
+ !default_uncertain_score.has_value()) {
+ LOG(ERROR) << "HpsFilterConfig error: missing params for "
+ "AverageFilterConfig for "
+ << feature_name;
return absl::nullopt;
}
@@ -177,32 +182,33 @@
} // namespace
absl::optional<hps::FeatureConfig> GetEnableHpsSenseConfig() {
- return ConstructHpsFilterConfigFromFeatureParams(features::kQuickDim);
+ return ConstructHpsFilterConfigFromFeatureParams(
+ features::kQuickDim, GetDefaultHpsSenseFeatureConfig());
}
absl::optional<hps::FeatureConfig> GetEnableHpsNotifyConfig() {
return ConstructHpsFilterConfigFromFeatureParams(
- features::kSnoopingProtection);
+ features::kSnoopingProtection, GetDefaultHpsNotifyFeatureConfig());
}
base::TimeDelta GetQuickDimDelay() {
const int quick_dim_ms = base::GetFieldTrialParamByFeatureAsInt(
- features::kQuickDim, "quick_dim_ms",
+ features::kQuickDim, "QuickDim_quick_dim_ms",
kQuickDimDelayDefault.InMilliseconds());
return base::Milliseconds(quick_dim_ms);
}
base::TimeDelta GetQuickLockDelay() {
const int quick_lock_ms = base::GetFieldTrialParamByFeatureAsInt(
- features::kQuickDim, "quick_lock_ms",
+ features::kQuickDim, "QuickDim_quick_lock_ms",
kQuickLockDelayDefault.InMilliseconds());
return base::Milliseconds(quick_lock_ms);
}
bool GetQuickDimFeedbackEnabled() {
- return base::GetFieldTrialParamByFeatureAsBool(features::kQuickDim,
- "send_feedback_if_undimmed",
- kShouldSendFeedbackIfUndimmed);
+ return base::GetFieldTrialParamByFeatureAsBool(
+ features::kQuickDim, "QuickDim_send_feedback_if_undimmed",
+ kShouldSendFeedbackIfUndimmed);
}
} // namespace ash
diff --git a/ash/system/hps/hps_configuration_unittest.cc b/ash/system/hps/hps_configuration_unittest.cc
index 30d37ee..157a797 100644
--- a/ash/system/hps/hps_configuration_unittest.cc
+++ b/ash/system/hps/hps_configuration_unittest.cc
@@ -27,74 +27,119 @@
{features::kQuickDim, features::kSnoopingProtection},
{} /* disabled_features */);
- EXPECT_TRUE(GetEnableHpsSenseConfig().has_value());
- EXPECT_TRUE(GetEnableHpsNotifyConfig().has_value());
+ EXPECT_EQ(GetEnableHpsSenseConfig()->filter_config_case(),
+ hps::FeatureConfig::kConsecutiveResultsFilterConfig);
+ EXPECT_EQ(GetEnableHpsNotifyConfig()->filter_config_case(),
+ hps::FeatureConfig::kAverageFilterConfig);
}
-TEST(HpsFeatureConfigTest, ReturnNullIfTypeIsNotRecognizable) {
- const base::FieldTrialParams params = {{"filter_config_case", "0"}};
+TEST(HpsFeatureConfigTest, ReturnNullIfTypeIsNotRecognizableHpsSense) {
+ const base::FieldTrialParams params = {{"QuickDim_filter_config_case", "0"}};
base::test::ScopedFeatureList feature_list;
- feature_list.InitWithFeaturesAndParameters(
- {{features::kQuickDim, params}, {features::kSnoopingProtection, params}},
- {});
+ feature_list.InitWithFeaturesAndParameters({{features::kQuickDim, params}},
+ {});
EXPECT_FALSE(GetEnableHpsSenseConfig().has_value());
+}
+
+TEST(HpsFeatureConfigTest, ReturnNullIfTypeIsNotRecognizableHpsNotify) {
+ const base::FieldTrialParams params = {
+ {"SnoopingProtection_filter_config_case", "0"}};
+ base::test::ScopedFeatureList feature_list;
+ feature_list.InitWithFeaturesAndParameters(
+ {{features::kSnoopingProtection, params}}, {});
+
EXPECT_FALSE(GetEnableHpsNotifyConfig().has_value());
}
-TEST(HpsFeatureConfigTest, VerifyBasicFilterConfig) {
+TEST(HpsFeatureConfigTest, VerifyBasicFilterConfigHpsSense) {
const std::map<std::string, std::string> params = {
- {"filter_config_case", "1"}};
+ {"QuickDim_filter_config_case", "1"}};
base::test::ScopedFeatureList feature_list;
- feature_list.InitWithFeaturesAndParameters(
- {{features::kQuickDim, params}, {features::kSnoopingProtection, params}},
- {});
+ feature_list.InitWithFeaturesAndParameters({{features::kQuickDim, params}},
+ {});
hps::FeatureConfig expected_config;
expected_config.mutable_basic_filter_config();
EXPECT_THAT(GetEnableHpsSenseConfig().value(), ProtoEquals(expected_config));
+}
+
+TEST(HpsFeatureConfigTest, VerifyBasicFilterConfigHpsNotify) {
+ const std::map<std::string, std::string> params = {
+ {"SnoopingProtection_filter_config_case", "1"}};
+ base::test::ScopedFeatureList feature_list;
+ feature_list.InitWithFeaturesAndParameters(
+ {{features::kSnoopingProtection, params}}, {});
+
+ hps::FeatureConfig expected_config;
+ expected_config.mutable_basic_filter_config();
+
EXPECT_THAT(GetEnableHpsNotifyConfig().value(), ProtoEquals(expected_config));
}
-TEST(HpsFeatureConfigTest, VerifyConsecutiveResultsFilterConfig) {
+TEST(HpsFeatureConfigTest, VerifyConsecutiveResultsFilterConfigHpsSense) {
const std::map<std::string, std::string> params = {
- {"filter_config_case", "2"},
- {"count", "3"},
- {"threshold", "4"},
- {"initial_state", "false"}};
+ {"QuickDim_filter_config_case", "2"},
+ {"QuickDim_positive_count_threshold", "3"},
+ {"QuickDim_negative_count_threshold", "4"},
+ {"QuickDim_uncertain_count_threshold", "5"},
+ {"QuickDim_positive_score_threshold", "7"},
+ {"QuickDim_negative_score_threshold", "6"},
+ };
base::test::ScopedFeatureList feature_list;
- feature_list.InitWithFeaturesAndParameters(
- {{features::kQuickDim, params}, {features::kSnoopingProtection, params}},
- {});
+ feature_list.InitWithFeaturesAndParameters({{features::kQuickDim, params}},
+ {});
hps::FeatureConfig expected_config;
auto& consecutive_results_filter_config =
*expected_config.mutable_consecutive_results_filter_config();
- consecutive_results_filter_config.set_count(3);
- consecutive_results_filter_config.set_threshold(4);
- consecutive_results_filter_config.set_initial_state(false);
+ consecutive_results_filter_config.set_positive_count_threshold(3);
+ consecutive_results_filter_config.set_negative_count_threshold(4);
+ consecutive_results_filter_config.set_uncertain_count_threshold(5);
+ consecutive_results_filter_config.set_positive_score_threshold(7);
+ consecutive_results_filter_config.set_negative_score_threshold(6);
const auto hps_sense_config = GetEnableHpsSenseConfig();
- ASSERT_TRUE(hps_sense_config.has_value());
EXPECT_THAT(*hps_sense_config, ProtoEquals(expected_config));
+}
+
+TEST(HpsFeatureConfigTest, VerifyConsecutiveResultsFilterConfigHpsNotify) {
+ const std::map<std::string, std::string> params = {
+ {"SnoopingProtection_filter_config_case", "2"},
+ {"SnoopingProtection_positive_count_threshold", "3"},
+ {"SnoopingProtection_negative_count_threshold", "4"},
+ {"SnoopingProtection_uncertain_count_threshold", "5"},
+ {"SnoopingProtection_positive_score_threshold", "7"},
+ {"SnoopingProtection_negative_score_threshold", "6"},
+ };
+ base::test::ScopedFeatureList feature_list;
+ feature_list.InitWithFeaturesAndParameters(
+ {{features::kSnoopingProtection, params}}, {});
+
+ hps::FeatureConfig expected_config;
+ auto& consecutive_results_filter_config =
+ *expected_config.mutable_consecutive_results_filter_config();
+ consecutive_results_filter_config.set_positive_count_threshold(3);
+ consecutive_results_filter_config.set_negative_count_threshold(4);
+ consecutive_results_filter_config.set_uncertain_count_threshold(5);
+ consecutive_results_filter_config.set_positive_score_threshold(7);
+ consecutive_results_filter_config.set_negative_score_threshold(6);
const auto hps_notify_config = GetEnableHpsNotifyConfig();
- ASSERT_TRUE(hps_notify_config.has_value());
EXPECT_THAT(*hps_notify_config, ProtoEquals(expected_config));
}
-TEST(HpsFeatureConfigTest, VerifyAverageFilterConfig) {
+TEST(HpsFeatureConfigTest, VerifyAverageFilterConfigHpsSense) {
const std::map<std::string, std::string> params = {
- {"filter_config_case", "3"},
- {"average_window_size", "4"},
- {"positive_score_threshold", "5"},
- {"negative_score_threshold", "6"},
- {"default_uncertain_score", "7"}};
+ {"QuickDim_filter_config_case", "3"},
+ {"QuickDim_average_window_size", "4"},
+ {"QuickDim_positive_score_threshold", "5"},
+ {"QuickDim_negative_score_threshold", "6"},
+ {"QuickDim_default_uncertain_score", "7"}};
base::test::ScopedFeatureList feature_list;
- feature_list.InitWithFeaturesAndParameters(
- {{features::kQuickDim, params}, {features::kSnoopingProtection, params}},
- {});
+ feature_list.InitWithFeaturesAndParameters({{features::kQuickDim, params}},
+ {});
hps::FeatureConfig expected_config;
auto& average_filter_config =
@@ -105,29 +150,30 @@
average_filter_config.set_default_uncertain_score(7);
const auto hps_sense_config = GetEnableHpsSenseConfig();
- ASSERT_TRUE(hps_sense_config.has_value());
EXPECT_THAT(*hps_sense_config, ProtoEquals(expected_config));
-
- const auto hps_notify_config = GetEnableHpsNotifyConfig();
- ASSERT_TRUE(hps_notify_config.has_value());
- EXPECT_THAT(*hps_notify_config, ProtoEquals(expected_config));
}
-TEST(HpsFeatureConfigTest, ExtraParamsInvalid) {
- // Valid params for the consecutive results filter, plus one extraneous param.
+TEST(HpsFeatureConfigTest, VerifyAverageFilterConfigHpsNotify) {
const std::map<std::string, std::string> params = {
- {"filter_config_case", "2"},
- {"count", "3"},
- {"threshold", "4"},
- {"initial_state", "false"},
- {"extra_param", ""}};
+ {"SnoopingProtection_filter_config_case", "3"},
+ {"SnoopingProtection_average_window_size", "4"},
+ {"SnoopingProtection_positive_score_threshold", "5"},
+ {"SnoopingProtection_negative_score_threshold", "6"},
+ {"SnoopingProtection_default_uncertain_score", "7"}};
base::test::ScopedFeatureList feature_list;
feature_list.InitWithFeaturesAndParameters(
- {{features::kQuickDim, params}, {features::kSnoopingProtection, params}},
- {});
+ {{features::kSnoopingProtection, params}}, {});
- EXPECT_FALSE(GetEnableHpsSenseConfig().has_value());
- EXPECT_FALSE(GetEnableHpsNotifyConfig().has_value());
+ hps::FeatureConfig expected_config;
+ auto& average_filter_config =
+ *expected_config.mutable_average_filter_config();
+ average_filter_config.set_average_window_size(4);
+ average_filter_config.set_positive_score_threshold(5);
+ average_filter_config.set_negative_score_threshold(6);
+ average_filter_config.set_default_uncertain_score(7);
+
+ const auto hps_notify_config = GetEnableHpsNotifyConfig();
+ EXPECT_THAT(*hps_notify_config, ProtoEquals(expected_config));
}
} // namespace ash
diff --git a/ash/system/unified/hps_notify_controller_unittest.cc b/ash/system/unified/hps_notify_controller_unittest.cc
index f646482..b38397d8 100644
--- a/ash/system/unified/hps_notify_controller_unittest.cc
+++ b/ash/system/unified/hps_notify_controller_unittest.cc
@@ -100,7 +100,7 @@
: HpsNotifyControllerTestBase(
/*service_available=*/true,
/*service_state=*/false,
- /*params=*/{{"filter_config_case", "1"}}) {}
+ /*params=*/{{"SnoopingProtection_filter_config_case", "1"}}) {}
};
// Test that icon is hidden by default.
@@ -222,7 +222,7 @@
: HpsNotifyControllerTestBase(
/*service_available=*/true,
/*service_state=*/true,
- /*params=*/{{"filter_config_case", "1"}}) {}
+ /*params=*/{{"SnoopingProtection_filter_config_case", "1"}}) {}
};
// Test that initial daemon state is considered.
@@ -343,7 +343,7 @@
: HpsNotifyControllerTestBase(
/*service_available=*/false,
/*service_state=*/true,
- /*params=*/{{"filter_config_case", "1"}}) {}
+ /*params=*/{{"SnoopingProtection_filter_config_case", "1"}}) {}
};
// Test that the controller waits for the DBus service to be available and
@@ -381,7 +381,7 @@
: HpsNotifyControllerTestBase(
/*service_available=*/true,
/*service_state=*/true,
- /*params=*/{{"filter_config_case", "0"}}) {}
+ /*params=*/{{"SnoopingProtection_filter_config_case", "0"}}) {}
};
// Test that the controller gracefully handles invalid feature parameters.
diff --git a/chrome/browser/about_flags.cc b/chrome/browser/about_flags.cc
index 9adc75a0..8542944 100644
--- a/chrome/browser/about_flags.cc
+++ b/chrome/browser/about_flags.cc
@@ -2651,22 +2651,25 @@
// sample.
const FeatureEntry::FeatureParam kSnoopingProtectionPrecision[] = {
- {"filter_config_case", "2"},
- {"count", "3"},
- {"threshold", "40"},
- {"initial_state", "false"}};
+ {"SnoopingProtection_filter_config_case", "3"},
+ {"SnoopingProtection_average_window_size", "3"},
+ {"SnoopingProtection_positive_score_threshold", "-30"},
+ {"SnoopingProtection_negative_score_threshold", "-30"},
+ {"SnoopingProtection_default_uncertain_score", "-128"}};
const FeatureEntry::FeatureParam kSnoopingProtectionConfidence[] = {
- {"filter_config_case", "2"},
- {"count", "5"},
- {"threshold", "40"},
- {"initial_state", "false"}};
+ {"SnoopingProtection_filter_config_case", "3"},
+ {"SnoopingProtection_average_window_size", "5"},
+ {"SnoopingProtection_positive_score_threshold", "-30"},
+ {"SnoopingProtection_negative_score_threshold", "-30"},
+ {"SnoopingProtection_default_uncertain_score", "-128"}};
const FeatureEntry::FeatureParam kSnoopingProtectionRecall[] = {
- {"filter_config_case", "2"},
- {"count", "3"},
- {"threshold", "-40"},
- {"initial_state", "false"}};
+ {"SnoopingProtection_filter_config_case", "3"},
+ {"SnoopingProtection_average_window_size", "3"},
+ {"SnoopingProtection_positive_score_threshold", "-70"},
+ {"SnoopingProtection_negative_score_threshold", "-70"},
+ {"SnoopingProtection_default_uncertain_score", "-128"}};
const FeatureEntry::FeatureVariation kSnoopingProtectionVariations[] = {
{"Precise", kSnoopingProtectionPrecision,
@@ -2676,30 +2679,89 @@
{"Comprehensive", kSnoopingProtectionRecall,
base::size(kSnoopingProtectionRecall), nullptr}};
-const FeatureEntry::FeatureParam kQuickDim120s[] = {{"quick_dim_ms", "120000"}};
+const FeatureEntry::FeatureParam kQuickDim120s[] = {
+ {"QuickDim_quick_dim_ms", "120000"},
+ {"QuickDim_filter_config_case", "2"},
+ {"QuickDim_positive_count_threshold", "1"},
+ {"QuickDim_negative_count_threshold", "2"},
+ {"QuickDim_uncertain_count_threshold", "2"},
+ {"QuickDim_positive_score_threshold", "0"},
+ {"QuickDim_negative_score_threshold", "0"},
+};
-const FeatureEntry::FeatureParam kQuickDim45s[] = {{"quick_dim_ms", "45000"}};
+const FeatureEntry::FeatureParam kQuickDim45s[] = {
+ {"QuickDim_quick_dim_ms", "45000"},
+ {"QuickDim_filter_config_case", "2"},
+ {"QuickDim_positive_count_threshold", "1"},
+ {"QuickDim_negative_count_threshold", "2"},
+ {"QuickDim_uncertain_count_threshold", "2"},
+ {"QuickDim_positive_score_threshold", "0"},
+ {"QuickDim_negative_score_threshold", "0"},
+};
-const FeatureEntry::FeatureParam kQuickDim10s[] = {{"quick_dim_ms", "10000"}};
+const FeatureEntry::FeatureParam kQuickDim10s[] = {
+ {"QuickDim_quick_dim_ms", "10000"},
+ {"QuickDim_filter_config_case", "2"},
+ {"QuickDim_positive_count_threshold", "1"},
+ {"QuickDim_negative_count_threshold", "2"},
+ {"QuickDim_uncertain_count_threshold", "2"},
+ {"QuickDim_positive_score_threshold", "0"},
+ {"QuickDim_negative_score_threshold", "0"},
+};
const FeatureEntry::FeatureParam kQuickDimInstantly[] = {
- {"quick_dim_ms", "1000"}};
+ {"QuickDim_quick_dim_ms", "1000"},
+ {"QuickDim_filter_config_case", "2"},
+ {"QuickDim_positive_count_threshold", "1"},
+ {"QuickDim_negative_count_threshold", "1"},
+ {"QuickDim_uncertain_count_threshold", "2"},
+ {"QuickDim_positive_score_threshold", "0"},
+ {"QuickDim_negative_score_threshold", "0"},
+};
const FeatureEntry::FeatureParam kQuickDim10sQuickLock40s[] = {
- {"quick_dim_ms", "10000"},
- {"quick_lock_ms", "40000"}};
+ {"QuickDim_quick_dim_ms", "10000"},
+ {"QuickDim_quick_lock_ms", "40000"},
+ {"QuickDim_filter_config_case", "2"},
+ {"QuickDim_positive_count_threshold", "1"},
+ {"QuickDim_negative_count_threshold", "2"},
+ {"QuickDim_uncertain_count_threshold", "2"},
+ {"QuickDim_positive_score_threshold", "0"},
+ {"QuickDim_negative_score_threshold", "0"},
+};
const FeatureEntry::FeatureParam kQuickDim10sQuickLock70s[] = {
- {"quick_dim_ms", "10000"},
- {"quick_lock_ms", "70000"}};
+ {"QuickDim_quick_dim_ms", "10000"},
+ {"QuickDim_quick_lock_ms", "70000"},
+ {"QuickDim_filter_config_case", "2"},
+ {"QuickDim_positive_count_threshold", "1"},
+ {"QuickDim_negative_count_threshold", "2"},
+ {"QuickDim_uncertain_count_threshold", "2"},
+ {"QuickDim_positive_score_threshold", "0"},
+ {"QuickDim_negative_score_threshold", "0"},
+};
const FeatureEntry::FeatureParam kQuickDim45sQuickLock135s[] = {
- {"quick_dim_ms", "45000"},
- {"quick_lock_ms", "135000"}};
+ {"QuickDim_quick_dim_ms", "45000"},
+ {"QuickDim_quick_lock_ms", "135000"},
+ {"QuickDim_filter_config_case", "2"},
+ {"QuickDim_positive_count_threshold", "1"},
+ {"QuickDim_negative_count_threshold", "2"},
+ {"QuickDim_uncertain_count_threshold", "2"},
+ {"QuickDim_positive_score_threshold", "0"},
+ {"QuickDim_negative_score_threshold", "0"},
+};
const FeatureEntry::FeatureParam kQuickDim120sQuickLock240s[] = {
- {"quick_dim_ms", "120000"},
- {"quick_lock_ms", "240000"}};
+ {"QuickDim_quick_dim_ms", "120000"},
+ {"QuickDim_quick_lock_ms", "240000"},
+ {"QuickDim_filter_config_case", "2"},
+ {"QuickDim_positive_count_threshold", "1"},
+ {"QuickDim_negative_count_threshold", "2"},
+ {"QuickDim_uncertain_count_threshold", "2"},
+ {"QuickDim_positive_score_threshold", "0"},
+ {"QuickDim_negative_score_threshold", "0"},
+};
const FeatureEntry::FeatureVariation kQuickDimVariations[] = {
{"QuickDim120s", kQuickDim120s, base::size(kQuickDim120s), nullptr},
