1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/platform/graphics/dark_mode_settings_builder.h"
#include <string>
#include <unordered_map>
#include "base/command_line.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "third_party/blink/public/common/features.h"
#include "third_party/blink/public/common/forcedark/forcedark_switches.h"
#include "third_party/blink/renderer/platform/graphics/dark_mode_settings.h"
namespace blink {
namespace {
// Default values for dark mode settings.
const constexpr DarkModeInversionAlgorithm kDefaultDarkModeInversionAlgorithm =
DarkModeInversionAlgorithm::kInvertLightnessLAB;
const constexpr DarkModeImagePolicy kDefaultDarkModeImagePolicy =
DarkModeImagePolicy::kFilterSmart;
const constexpr DarkModeImageClassifierPolicy
kDefaultDarkModeImageClassifierPolicy =
DarkModeImageClassifierPolicy::kNumColorsWithMlFallback;
const constexpr int kDefaultForegroundBrightnessThreshold = 150;
const constexpr int kDefaultBackgroundBrightnessThreshold = 205;
const constexpr float kDefaultDarkModeContrastPercent = 0.0f;
typedef std::unordered_map<std::string, std::string> SwitchParams;
SwitchParams ParseDarkModeSettings() {
SwitchParams switch_params;
if (!base::CommandLine::ForCurrentProcess()->HasSwitch("dark-mode-settings"))
return switch_params;
std::vector<std::string> param_values = base::SplitString(
base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
"dark-mode-settings"),
",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
for (auto param_value : param_values) {
std::vector<std::string> pair = base::SplitString(
param_value, "=", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
if (pair.size() == 2)
switch_params[base::ToLowerASCII(pair[0])] = base::ToLowerASCII(pair[1]);
}
return switch_params;
}
template <typename T>
T GetIntegerSwitchParamValue(const SwitchParams& switch_params,
std::string param,
T default_value) {
auto it = switch_params.find(base::ToLowerASCII(param));
if (it == switch_params.end())
return default_value;
int result;
return base::StringToInt(it->second, &result) ? static_cast<T>(result)
: default_value;
}
float GetFloatSwitchParamValue(const SwitchParams& switch_params,
std::string param,
float default_value) {
auto it = switch_params.find(base::ToLowerASCII(param));
if (it == switch_params.end())
return default_value;
double result;
return base::StringToDouble(it->second, &result) ? static_cast<float>(result)
: default_value;
}
DarkModeInversionAlgorithm GetMode(const SwitchParams& switch_params) {
switch (features::kForceDarkInversionMethodParam.Get()) {
case ForceDarkInversionMethod::kUseBlinkSettings:
return GetIntegerSwitchParamValue<DarkModeInversionAlgorithm>(
switch_params, "InversionAlgorithm",
kDefaultDarkModeInversionAlgorithm);
case ForceDarkInversionMethod::kCielabBased:
return DarkModeInversionAlgorithm::kInvertLightnessLAB;
case ForceDarkInversionMethod::kHslBased:
return DarkModeInversionAlgorithm::kInvertLightness;
case ForceDarkInversionMethod::kRgbBased:
return DarkModeInversionAlgorithm::kInvertBrightness;
}
NOTREACHED();
}
DarkModeImageClassifierPolicy GetImageClassifierPolicy(
const SwitchParams& switch_params) {
switch (features::kForceDarkImageClassifierParam.Get()) {
case ForceDarkImageClassifier::kUseBlinkSettings:
return GetIntegerSwitchParamValue<DarkModeImageClassifierPolicy>(
switch_params, "ImageClassifierPolicy",
kDefaultDarkModeImageClassifierPolicy);
case ForceDarkImageClassifier::kNumColorsWithMlFallback:
return DarkModeImageClassifierPolicy::kNumColorsWithMlFallback;
case ForceDarkImageClassifier::kTransparencyAndNumColors:
return DarkModeImageClassifierPolicy::kTransparencyAndNumColors;
}
}
DarkModeImagePolicy GetImagePolicy(const SwitchParams& switch_params) {
switch (features::kForceDarkImageBehaviorParam.Get()) {
case ForceDarkImageBehavior::kUseBlinkSettings:
return GetIntegerSwitchParamValue<DarkModeImagePolicy>(
switch_params, "ImagePolicy", kDefaultDarkModeImagePolicy);
case ForceDarkImageBehavior::kInvertNone:
return DarkModeImagePolicy::kFilterNone;
case ForceDarkImageBehavior::kInvertSelectively:
return DarkModeImagePolicy::kFilterSmart;
}
}
int GetForegroundBrightnessThreshold(const SwitchParams& switch_params) {
const int flag_value =
features::kForceDarkForegroundLightnessThresholdParam.Get();
return flag_value >= 0 ? flag_value
: GetIntegerSwitchParamValue<int>(
switch_params, "ForegroundBrightnessThreshold",
kDefaultForegroundBrightnessThreshold);
}
int GetBackgroundBrightnessThreshold(const SwitchParams& switch_params) {
const int flag_value =
features::kForceDarkBackgroundLightnessThresholdParam.Get();
return flag_value >= 0 ? flag_value
: GetIntegerSwitchParamValue<int>(
switch_params, "BackgroundBrightnessThreshold",
kDefaultBackgroundBrightnessThreshold);
}
template <typename T>
T Clamp(T value, T min_value, T max_value) {
return std::max(min_value, std::min(value, max_value));
}
DarkModeSettings BuildDarkModeSettings() {
SwitchParams switch_params = ParseDarkModeSettings();
DarkModeSettings settings;
settings.mode = Clamp<DarkModeInversionAlgorithm>(
GetMode(switch_params), DarkModeInversionAlgorithm::kFirst,
DarkModeInversionAlgorithm::kLast);
settings.image_policy = Clamp<DarkModeImagePolicy>(
GetImagePolicy(switch_params), DarkModeImagePolicy::kFirst,
DarkModeImagePolicy::kLast);
settings.image_classifier_policy = Clamp<DarkModeImageClassifierPolicy>(
GetImageClassifierPolicy(switch_params),
DarkModeImageClassifierPolicy::kFirst,
DarkModeImageClassifierPolicy::kLast);
settings.foreground_brightness_threshold =
Clamp<int>(GetForegroundBrightnessThreshold(switch_params), 0, 255);
settings.background_brightness_threshold =
Clamp<int>(GetBackgroundBrightnessThreshold(switch_params), 0, 255);
settings.contrast =
Clamp<float>(GetFloatSwitchParamValue(switch_params, "ContrastPercent",
kDefaultDarkModeContrastPercent),
-1.0f, 1.0f);
return settings;
}
} // namespace
const DarkModeSettings& GetCurrentDarkModeSettings() {
static DarkModeSettings settings = BuildDarkModeSettings();
return settings;
}
} // namespace blink
|
