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
|
// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_COMPOSE_CORE_BROWSER_CONFIG_H_
#define COMPONENTS_COMPOSE_CORE_BROWSER_CONFIG_H_
#include <string>
#include <vector>
#include "base/containers/flat_set.h"
#include "base/time/time.h"
namespace compose {
// How Compose should position its dialog if there isn't enough space above or
// below the underlying form field (the `anchor`) on the screen.
enum class DialogFallbackPositioningStrategy : int {
// This adjusts the position so that the dialog's top border will never have
// to move to keep the bottom border onscreen, regardless of the actual size
// of the dialog. This may result in the dialog being rendered higher on
// screen that expected, obscuring the underlying element more than absolutely
// necessary. It has the advantage that the dialog is not repositioned when it
// grows, resulting in less jarring resizes.
kShiftUpUntilMaxSizeIsOnscreen = 0,
// This adjusts the dialog to be centered over its underlying form element,
// which has the advantage of always being close to the relevant page content,
// but will obscure more of the form field than other strategies.
kCenterOnAnchorRect = 1,
// This adjusts the dialog to be onscreen, but no further. This has the
// advantage of not obscuring the underlying element more than necesasary, but
// the downside that the dialog will move in position as it resizes. In
// practice this is more visually jarring than just making the dialog bigger.
kShiftUpUntilOnscreen = 2
};
// The Compose configuration. Default values appear below. Always use
// |GetComposeConfig()| to get the current configuration.
struct Config {
// The minimum number of words needed for a valid user input.
unsigned int input_min_words = 3;
// The maximum number of words allowed for a valid user input.
unsigned int input_max_words = 500;
// The maximum number of characters allowed for a valid user input.
unsigned int input_max_chars = 2500;
// The maximum number of bytes allowed in the inner text.
unsigned int inner_text_max_bytes = 1024 * 1024;
// The maximum number of bytes allowed in the inner text.
unsigned int trimmed_inner_text_max_chars = 12000;
// The maximum number of bytes allowed in the inner text.
unsigned int trimmed_inner_text_header_length = 4000;
// The maximum number of AX nodes to gather for page context.
unsigned int max_ax_node_count_for_page_context = 5000;
// Whether to send a compose when the dialog is first opened,
// if there is an acceptable input text selected.
bool auto_submit_with_selection = false;
// Whether to enable the nudge on focus when there is saved state.
bool saved_state_nudge_enabled = true;
// Whether to enable the proactive nudge with no saved state.
bool proactive_nudge_enabled = true;
// Use the compact UI for proactive nudge.
bool proactive_nudge_compact_ui = true;
// Whether or not the proactive nudge is shown at the cursor.
bool is_nudge_shown_at_cursor = true;
// Used to randomly hide the nudge in order to reduce exposure, experimental
// flag for triggering research experiments only. If param is greater than
// `1`, always shows. If param is negative, never shows.
double proactive_nudge_show_probability = 0.02;
// When segmentation is enabled and working, this parameter controls how often
// we randomly decide to show the proactive nudge regardless of the
// segmentation platform's response. Nudges shown in this way contribute to
// training data for the segmentation platform.
double proactive_nudge_force_show_probability = 0.004;
// Whether to collect training data for the segmentation platform any time the
// nudge is shown. If false, training data is only collected when the nudge is
// randomly force-shown, see `proactive_nudge_force_show_probability`.
bool proactive_nudge_always_collect_training_data = false;
// Ignores OptGuide decision to disable the nudge. Does not bypass other
// hint decisions.
bool proactive_nudge_bypass_optimization_guide = false;
// Uses segmentation platform to predict nudge utility.
bool proactive_nudge_segmentation = true;
// How long to wait to show the proactive nudge after focus. A non-positive
// value disables the focus nudge.
base::TimeDelta proactive_nudge_focus_delay = base::Seconds(0);
// How long to wait to show the proactive nudge after valid text input. A
// non-positive value disables the after input nudge.
base::TimeDelta proactive_nudge_text_settled_delay = base::Seconds(1);
// How many text change events to wait for before showing the after text input
// nudge.
int proactive_nudge_text_change_count = 10;
// List of countries where the proactive nudge is enabled. The default value
// is set in the constructor.
base::flat_set<std::string> proactive_nudge_countries;
// Whether the nudge on selection should be enabled.
bool selection_nudge_enabled = false;
// Minimum selection length needed before showing the selection nudge.
unsigned int selection_nudge_length = 30;
// How long to wait to show the selection nudge.
base::TimeDelta selection_nudge_delay = base::Milliseconds(500);
// Whether the selection nudge can be shown more than once per focus.
bool selection_nudge_once_per_focus = false;
// If true, nudge at most once per field per navigation. If false, at most
// once per field per focus.
bool proactive_nudge_field_per_navigation = true;
// How many text change events to wait for before dismissing the nudge.
unsigned int nudge_field_change_event_max = 3;
// The duration that the saved state notification is shown before
// auto-dismissal.
base::TimeDelta saved_state_timeout = base::Milliseconds(2000);
// The delay to wait to show the saved state notification after the compose
// dialog loses focus.
base::TimeDelta focus_lost_delay = base::Milliseconds(100);
// Whether the dialog should prioritize staying within bounds of the browser
// window above visibility of the anchor rect.
bool stay_in_window_bounds = true;
// The dialog positioning strategy to use if there isn't enough space above or
// below the anchor element.
DialogFallbackPositioningStrategy positioning_strategy =
DialogFallbackPositioningStrategy::kShiftUpUntilMaxSizeIsOnscreen;
// The threshold for Compose request latency before showing a client-side
// error message.
base::TimeDelta request_latency_timeout = base::Seconds(20);
// Finch-controllable list of countries where Compose should be enabled. The
// default value is set in the constructor.
base::flat_set<std::string> enabled_countries;
// The threshold for the lifetime of a Compose session. A session whose
// lifetime has exceeded this threshold will be replaced with a new session
// the next time there is an attempt to resume it.
base::TimeDelta session_max_allowed_lifetime = base::Minutes(30);
Config();
Config(const Config& other);
~Config();
};
// Gets the current configuration.
const Config& GetComposeConfig();
Config& GetMutableConfigForTesting();
void ResetConfigForTesting();
} // namespace compose
#endif // COMPONENTS_COMPOSE_CORE_BROWSER_CONFIG_H_
|
