blob: 9646d308b0b27cd86737293fafd11d4ff80aaac4 [file] [log] [blame]
[email protected]9c66adc2012-01-05 02:10:161// Copyright (c) 2012 The Chromium Authors. All rights reserved.
[email protected]ad2a3ded2010-08-27 13:19:052// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
[email protected]1a47d7e2010-10-15 00:37:245#include "chrome/browser/about_flags.h"
[email protected]ad2a3ded2010-08-27 13:19:056
7#include <algorithm>
8#include <iterator>
9#include <map>
10#include <set>
11
[email protected]ad2a3ded2010-08-27 13:19:0512#include "base/command_line.h"
[email protected]3b63f8f42011-03-28 01:54:1513#include "base/memory/singleton.h"
[email protected]8a6ff28d2010-12-02 16:35:1914#include "base/string_number_conversions.h"
[email protected]d208f4d82011-05-23 21:52:0315#include "base/utf_string_conversions.h"
[email protected]ad2a3ded2010-08-27 13:19:0516#include "base/values.h"
[email protected]ad2a3ded2010-08-27 13:19:0517#include "chrome/browser/prefs/pref_service.h"
[email protected]1bc78422011-03-31 08:41:3818#include "chrome/browser/prefs/scoped_user_pref_update.h"
[email protected]d208f4d82011-05-23 21:52:0319#include "chrome/common/chrome_content_client.h"
[email protected]ad2a3ded2010-08-27 13:19:0520#include "chrome/common/chrome_switches.h"
21#include "chrome/common/pref_names.h"
[email protected]7f6f44c2011-12-14 13:23:3822#include "content/public/browser/user_metrics.h"
[email protected]ad2a3ded2010-08-27 13:19:0523#include "grit/generated_resources.h"
[email protected]c051a1b2011-01-21 23:30:1724#include "ui/base/l10n/l10n_util.h"
[email protected]c9c73ad42012-04-18 03:35:5925#include "ui/base/ui_base_switches.h"
[email protected]8ff7f342011-05-25 01:49:4726#include "ui/gfx/gl/gl_switches.h"
[email protected]ad2a3ded2010-08-27 13:19:0527
[email protected]dc04be7c2012-03-15 23:57:4928#if defined(USE_ASH)
[email protected]b65bdda2011-12-23 23:35:3129#include "ash/ash_switches.h"
[email protected]dc04be7c2012-03-15 23:57:4930#endif
31
32#if defined(USE_AURA)
[email protected]308aaa32012-03-12 13:14:5033#include "ui/aura/aura_switches.h"
[email protected]8cc10df2011-11-03 23:57:5034#endif
35
[email protected]7f6f44c2011-12-14 13:23:3836using content::UserMetricsAction;
37
[email protected]1a47d7e2010-10-15 00:37:2438namespace about_flags {
[email protected]ad2a3ded2010-08-27 13:19:0539
[email protected]8a6ff28d2010-12-02 16:35:1940// Macros to simplify specifying the type.
[email protected]a82744532011-02-11 16:15:5341#define SINGLE_VALUE_TYPE_AND_VALUE(command_line_switch, switch_value) \
42 Experiment::SINGLE_VALUE, command_line_switch, switch_value, NULL, 0
43#define SINGLE_VALUE_TYPE(command_line_switch) \
44 SINGLE_VALUE_TYPE_AND_VALUE(command_line_switch, "")
45#define MULTI_VALUE_TYPE(choices) \
[email protected]0e6f56d2011-02-12 23:45:1546 Experiment::MULTI_VALUE, "", "", choices, arraysize(choices)
[email protected]8a6ff28d2010-12-02 16:35:1947
[email protected]e2ddbc92010-10-15 20:02:0748namespace {
49
[email protected]9c7453d2012-01-21 00:45:4050const unsigned kOsAll = kOsMac | kOsWin | kOsLinux | kOsCrOS | kOsAndroid;
[email protected]ad2a3ded2010-08-27 13:19:0551
[email protected]cc3e2052011-12-20 01:01:4052// Adds a |StringValue| to |list| for each platform where |bitmask| indicates
53// whether the experiment is available on that platform.
54void AddOsStrings(unsigned bitmask, ListValue* list) {
55 struct {
56 unsigned bit;
57 const char* const name;
58 } kBitsToOs[] = {
59 {kOsMac, "Mac"},
60 {kOsWin, "Windows"},
61 {kOsLinux, "Linux"},
62 {kOsCrOS, "Chrome OS"},
63 };
64 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kBitsToOs); ++i)
65 if (bitmask & kBitsToOs[i].bit)
66 list->Append(new StringValue(kBitsToOs[i].name));
67}
68
[email protected]ba8164242010-11-16 21:31:0069// Names for former Chrome OS Labs experiments, shared with prefs migration
70// code.
71const char kMediaPlayerExperimentName[] = "media-player";
72const char kAdvancedFileSystemExperimentName[] = "advanced-file-system";
73const char kVerticalTabsExperimentName[] = "vertical-tabs";
74
[email protected]032d5e6c2012-02-17 17:53:5575const Experiment::Choice kOmniboxInlineHistoryQuickProviderChoices[] = {
76 { IDS_FLAGS_OMNIBOX_INLINE_HISTORY_QUICK_PROVIDER_AUTOMATIC, "", "" },
77 { IDS_FLAGS_OMNIBOX_INLINE_HISTORY_QUICK_PROVIDER_ALLOWED,
78 switches::kOmniboxInlineHistoryQuickProvider,
79 switches::kOmniboxInlineHistoryQuickProviderAllowed },
80 { IDS_FLAGS_OMNIBOX_INLINE_HISTORY_QUICK_PROVIDER_PROHIBITED,
81 switches::kOmniboxInlineHistoryQuickProvider,
82 switches::kOmniboxInlineHistoryQuickProviderProhibited }
83};
84
[email protected]72787e392012-03-23 05:55:4385const Experiment::Choice kThreadedCompositingModeChoices[] = {
86 { IDS_FLAGS_THREADED_COMPOSITING_MODE_DEFAULT, "", "" },
87 { IDS_FLAGS_THREADED_COMPOSITING_MODE_DISABLED,
88 switches::kDisableThreadedCompositing, ""},
89 { IDS_FLAGS_THREADED_COMPOSITING_MODE_ENABLED,
90 switches::kEnableThreadedCompositing, ""}
91};
92
[email protected]4bc5050c2010-11-18 17:55:5493// RECORDING USER METRICS FOR FLAGS:
94// -----------------------------------------------------------------------------
95// The first line of the experiment is the internal name. If you'd like to
96// gather statistics about the usage of your flag, you should append a marker
97// comment to the end of the feature name, like so:
98// "my-special-feature", // FLAGS:RECORD_UMA
99//
100// After doing that, run //chrome/tools/extract_actions.py (see instructions at
101// the top of that file for details) to update the chromeactions.txt file, which
102// will enable UMA to record your feature flag.
103//
104// After your feature has shipped under a flag, you can locate the metrics
105// under the action name AboutFlags_internal-action-name. Actions are recorded
106// once per startup, so you should divide this number by AboutFlags_StartupTick
107// to get a sense of usage. Note that this will not be the same as number of
108// users with a given feature enabled because users can quit and relaunch
109// the application multiple times over a given time interval.
110// TODO(rsesek): See if there's a way to count per-user, rather than
111// per-startup.
112
[email protected]8a6ff28d2010-12-02 16:35:19113// To add a new experiment add to the end of kExperiments. There are two
114// distinct types of experiments:
115// . SINGLE_VALUE: experiment is either on or off. Use the SINGLE_VALUE_TYPE
116// macro for this type supplying the command line to the macro.
[email protected]28e35af2011-02-09 12:56:22117// . MULTI_VALUE: a list of choices, the first of which should correspond to a
118// deactivated state for this lab (i.e. no command line option). To specify
119// this type of experiment use the macro MULTI_VALUE_TYPE supplying it the
120// array of choices.
[email protected]8a6ff28d2010-12-02 16:35:19121// See the documentation of Experiment for details on the fields.
122//
123// When adding a new choice, add it to the end of the list.
[email protected]ad2a3ded2010-08-27 13:19:05124const Experiment kExperiments[] = {
125 {
[email protected]aac169d2011-03-18 19:53:03126 "expose-for-tabs", // FLAGS:RECORD_UMA
127 IDS_FLAGS_TABPOSE_NAME,
128 IDS_FLAGS_TABPOSE_DESCRIPTION,
129 kOsMac,
130#if defined(OS_MACOSX)
131 // The switch exists only on OS X.
132 SINGLE_VALUE_TYPE(switches::kEnableExposeForTabs)
133#else
134 SINGLE_VALUE_TYPE("")
135#endif
136 },
137 {
[email protected]4bc5050c2010-11-18 17:55:54138 "conflicting-modules-check", // FLAGS:RECORD_UMA
[email protected]c1bbaa82010-11-08 11:17:05139 IDS_FLAGS_CONFLICTS_CHECK_NAME,
140 IDS_FLAGS_CONFLICTS_CHECK_DESCRIPTION,
141 kOsWin,
[email protected]8a6ff28d2010-12-02 16:35:19142 SINGLE_VALUE_TYPE(switches::kConflictingModulesCheck)
[email protected]c1bbaa82010-11-08 11:17:05143 },
144 {
[email protected]4bc5050c2010-11-18 17:55:54145 "cloud-print-proxy", // FLAGS:RECORD_UMA
[email protected]dae7325b2011-12-21 20:56:54146 IDS_FLAGS_CLOUD_PRINT_CONNECTOR_NAME,
147 IDS_FLAGS_CLOUD_PRINT_CONNECTOR_DESCRIPTION,
[email protected]9f8872b32011-03-04 19:44:45148 // For a Chrome build, we know we have a PDF plug-in on Windows, so it's
[email protected]4fa24bf2011-08-20 02:15:22149 // fully enabled.
[email protected]5d10d57d2011-07-22 22:16:31150 // Otherwise, where we know Windows could be working if a viable PDF
[email protected]4fa24bf2011-08-20 02:15:22151 // plug-in could be supplied, we'll keep the lab enabled. Mac and Linux
152 // always have PDF rasterization available, so no flag needed there.
153#if !defined(GOOGLE_CHROME_BUILD)
154 kOsWin,
155#else
156 0,
[email protected]fa6d2a2f2010-11-30 21:47:19157#endif
[email protected]8a6ff28d2010-12-02 16:35:19158 SINGLE_VALUE_TYPE(switches::kEnableCloudPrintProxy)
[email protected]8b6588a2010-10-12 02:39:42159 },
[email protected]580939a2010-10-12 18:54:37160 {
[email protected]bb461532010-11-26 21:50:23161 "crxless-web-apps",
162 IDS_FLAGS_CRXLESS_WEB_APPS_NAME,
163 IDS_FLAGS_CRXLESS_WEB_APPS_DESCRIPTION,
164 kOsAll,
[email protected]8a6ff28d2010-12-02 16:35:19165 SINGLE_VALUE_TYPE(switches::kEnableCrxlessWebApps)
[email protected]bb461532010-11-26 21:50:23166 },
167 {
[email protected]96c6f4c2011-05-18 19:36:22168 "ignore-gpu-blacklist",
169 IDS_FLAGS_IGNORE_GPU_BLACKLIST_NAME,
170 IDS_FLAGS_IGNORE_GPU_BLACKLIST_DESCRIPTION,
171 kOsAll,
172 SINGLE_VALUE_TYPE(switches::kIgnoreGpuBlacklist)
173 },
174 {
[email protected]0110cf112011-07-02 00:39:43175 "force-compositing-mode-2",
[email protected]96c6f4c2011-05-18 19:36:22176 IDS_FLAGS_FORCE_COMPOSITING_MODE_NAME,
177 IDS_FLAGS_FORCE_COMPOSITING_MODE_DESCRIPTION,
178 kOsAll,
179 SINGLE_VALUE_TYPE(switches::kForceCompositingMode)
180 },
181 {
[email protected]72787e392012-03-23 05:55:43182 "threaded-compositing-mode",
183 IDS_FLAGS_THREADED_COMPOSITING_MODE_NAME,
184 IDS_FLAGS_THREADED_COMPOSITING_MODE_DESCRIPTION,
[email protected]644a1072012-03-16 09:29:59185 kOsAll,
[email protected]72787e392012-03-23 05:55:43186 MULTI_VALUE_TYPE(kThreadedCompositingModeChoices)
[email protected]644a1072012-03-16 09:29:59187 },
188 {
[email protected]7d2e0532012-03-23 22:03:31189 "disable-threaded-animation",
190 IDS_FLAGS_DISABLE_THREADED_ANIMATION_NAME,
191 IDS_FLAGS_DISABLE_THREADED_ANIMATION_DESCRIPTION,
[email protected]644a1072012-03-16 09:29:59192 kOsAll,
[email protected]7d2e0532012-03-23 22:03:31193 SINGLE_VALUE_TYPE(switches::kDisableThreadedAnimation)
[email protected]644a1072012-03-16 09:29:59194 },
195 {
[email protected]5963b772011-02-09 22:55:38196 "composited-layer-borders",
197 IDS_FLAGS_COMPOSITED_LAYER_BORDERS,
198 IDS_FLAGS_COMPOSITED_LAYER_BORDERS_DESCRIPTION,
199 kOsAll,
200 SINGLE_VALUE_TYPE(switches::kShowCompositedLayerBorders)
201 },
202 {
[email protected]a8f1eaa2011-03-07 19:00:58203 "show-fps-counter",
204 IDS_FLAGS_SHOW_FPS_COUNTER,
205 IDS_FLAGS_SHOW_FPS_COUNTER_DESCRIPTION,
206 kOsAll,
207 SINGLE_VALUE_TYPE(switches::kShowFPSCounter)
208 },
[email protected]8ff7f342011-05-25 01:49:47209 {
[email protected]70c98a332011-12-21 20:51:52210 "accelerated-filters",
211 IDS_FLAGS_ACCELERATED_FILTERS,
212 IDS_FLAGS_ACCELERATED_FILTERS_DESCRIPTION,
213 kOsAll,
214 SINGLE_VALUE_TYPE(switches::kEnableAcceleratedFilters)
215 },
216 {
[email protected]8ff7f342011-05-25 01:49:47217 "disable-gpu-vsync",
218 IDS_FLAGS_DISABLE_GPU_VSYNC_NAME,
219 IDS_FLAGS_DISABLE_GPU_VSYNC_DESCRIPTION,
220 kOsAll,
221 SINGLE_VALUE_TYPE(switches::kDisableGpuVsync)
222 },
[email protected]deaba6d52011-09-23 14:47:12223 {
224 "disable-webgl",
225 IDS_FLAGS_DISABLE_WEBGL_NAME,
226 IDS_FLAGS_DISABLE_WEBGL_DESCRIPTION,
227 kOsAll,
228 SINGLE_VALUE_TYPE(switches::kDisableExperimentalWebGL)
229 },
[email protected]d208f4d82011-05-23 21:52:03230 // TODO(dspringer): When NaCl is on by default, remove this flag entry.
[email protected]2fe15fcb2010-10-21 20:39:53231 {
[email protected]e3791ce92011-08-09 01:03:32232 "enable-nacl", // FLAGS:RECORD_UMA
[email protected]4ff87d202010-11-06 01:28:40233 IDS_FLAGS_ENABLE_NACL_NAME,
234 IDS_FLAGS_ENABLE_NACL_DESCRIPTION,
235 kOsAll,
[email protected]8a6ff28d2010-12-02 16:35:19236 SINGLE_VALUE_TYPE(switches::kEnableNaCl)
[email protected]4ff87d202010-11-06 01:28:40237 },
[email protected]b39c6d92012-01-31 16:38:41238 // TODO(halyavin): When exception handling is on by default, replace this
239 // flag with disable-nacl-exception-handling.
240 {
241 "enable-nacl-exception-handling", // FLAGS:RECORD_UMA
242 IDS_FLAGS_ENABLE_NACL_EXCEPTION_HANDLING_NAME,
243 IDS_FLAGS_ENABLE_NACL_EXCEPTION_HANDLING_DESCRIPTION,
244 kOsWin,
245 SINGLE_VALUE_TYPE(switches::kEnableNaClExceptionHandling)
246 },
[email protected]4ff87d202010-11-06 01:28:40247 {
[email protected]31a665e72012-03-11 12:37:46248 "nacl-gdb", // FLAGS:RECORD_UMA
249 IDS_FLAGS_NACL_GDB_NAME,
250 IDS_FLAGS_NACL_GDB_DESCRIPTION,
251 kOsWin,
252 SINGLE_VALUE_TYPE(switches::kNaClGdb)
253 },
254 {
[email protected]4bc5050c2010-11-18 17:55:54255 "extension-apis", // FLAGS:RECORD_UMA
[email protected]11dd68cd52010-11-12 01:15:32256 IDS_FLAGS_EXPERIMENTAL_EXTENSION_APIS_NAME,
257 IDS_FLAGS_EXPERIMENTAL_EXTENSION_APIS_DESCRIPTION,
258 kOsAll,
[email protected]8a6ff28d2010-12-02 16:35:19259 SINGLE_VALUE_TYPE(switches::kEnableExperimentalExtensionApis)
[email protected]11dd68cd52010-11-12 01:15:32260 },
[email protected]3627b06d2010-11-12 16:36:16261 {
[email protected]f3c069622012-04-24 07:10:34262 "browser-actions-for-all",
263 IDS_FLAGS_BROWSER_ACTIONS_FOR_ALL_NAME,
264 IDS_FLAGS_BROWSER_ACTIONS_FOR_ALL_DESCRIPTION,
265 kOsAll,
266 SINGLE_VALUE_TYPE(switches::kEnableBrowserActionsForAll),
267 },
268 {
[email protected]cab18ef2012-04-27 07:22:03269 "action-box",
270 IDS_FLAGS_ACTION_BOX_NAME,
271 IDS_FLAGS_ACTION_BOX_DESCRIPTION,
272 kOsAll,
273 SINGLE_VALUE_TYPE(switches::kEnableActionBox),
274 },
275 {
[email protected]cbe224d2011-08-04 22:12:49276 "apps-new-install-bubble",
277 IDS_FLAGS_APPS_NEW_INSTALL_BUBBLE_NAME,
278 IDS_FLAGS_APPS_NEW_INSTALL_BUBBLE_DESCRIPTION,
279 kOsAll,
280 SINGLE_VALUE_TYPE(switches::kAppsNewInstallBubble)
281 },
282 {
[email protected]80bd24e2010-11-30 09:34:38283 "disable-hyperlink-auditing",
284 IDS_FLAGS_DISABLE_HYPERLINK_AUDITING_NAME,
285 IDS_FLAGS_DISABLE_HYPERLINK_AUDITING_DESCRIPTION,
286 kOsAll,
[email protected]8a6ff28d2010-12-02 16:35:19287 SINGLE_VALUE_TYPE(switches::kNoPings)
[email protected]feb28fef2010-12-01 10:52:51288 },
289 {
290 "experimental-location-features", // FLAGS:RECORD_UMA
291 IDS_FLAGS_EXPERIMENTAL_LOCATION_FEATURES_NAME,
292 IDS_FLAGS_EXPERIMENTAL_LOCATION_FEATURES_DESCRIPTION,
293 kOsMac | kOsWin | kOsLinux, // Currently does nothing on CrOS.
[email protected]8a6ff28d2010-12-02 16:35:19294 SINGLE_VALUE_TYPE(switches::kExperimentalLocationFeatures)
295 },
296 {
[email protected]04227962011-01-20 02:03:09297 "disable-interactive-form-validation",
298 IDS_FLAGS_DISABLE_INTERACTIVE_FORM_VALIDATION_NAME,
299 IDS_FLAGS_DISABLE_INTERACTIVE_FORM_VALIDATION_DESCRIPTION,
300 kOsAll,
301 SINGLE_VALUE_TYPE(switches::kDisableInteractiveFormValidation)
302 },
[email protected]8df51192011-01-22 20:05:03303 {
[email protected]07d490bc2011-03-07 17:05:26304 "focus-existing-tab-on-open", // FLAGS:RECORD_UMA
305 IDS_FLAGS_FOCUS_EXISTING_TAB_ON_OPEN_NAME,
306 IDS_FLAGS_FOCUS_EXISTING_TAB_ON_OPEN_DESCRIPTION,
307 kOsAll,
308 SINGLE_VALUE_TYPE(switches::kFocusExistingTabOnOpen)
309 },
[email protected]d5dcfb32011-03-19 00:49:24310 {
[email protected]5aea1862011-03-23 23:55:39311 "tab-groups-context-menu",
312 IDS_FLAGS_TAB_GROUPS_CONTEXT_MENU_NAME,
313 IDS_FLAGS_TAB_GROUPS_CONTEXT_MENU_DESCRIPTION,
314 kOsWin,
315 SINGLE_VALUE_TYPE(switches::kEnableTabGroupsContextMenu)
316 },
[email protected]e9bf9d92011-03-31 20:57:15317 {
[email protected]354e33b2011-06-15 00:29:10318 "static-ip-config",
319 IDS_FLAGS_STATIC_IP_CONFIG_NAME,
320 IDS_FLAGS_STATIC_IP_CONFIG_DESCRIPTION,
321 kOsCrOS,
322#if defined(OS_CHROMEOS)
323 // This switch exists only on Chrome OS.
324 SINGLE_VALUE_TYPE(switches::kEnableStaticIPConfig)
325#else
326 SINGLE_VALUE_TYPE("")
327#endif
328 },
[email protected]3eb5728c2011-06-20 22:32:24329 {
330 "show-autofill-type-predictions",
331 IDS_FLAGS_SHOW_AUTOFILL_TYPE_PREDICTIONS_NAME,
332 IDS_FLAGS_SHOW_AUTOFILL_TYPE_PREDICTIONS_DESCRIPTION,
333 kOsAll,
334 SINGLE_VALUE_TYPE(switches::kShowAutofillTypePredictions)
335 },
[email protected]bff4d3e2011-06-21 23:58:52336 {
[email protected]9a6180d7d2011-09-07 01:40:33337 "sync-tabs",
338 IDS_FLAGS_SYNC_TABS_NAME,
339 IDS_FLAGS_SYNC_TABS_DESCRIPTION,
[email protected]5b0ec7f2011-08-11 02:17:17340 kOsAll,
[email protected]9a6180d7d2011-09-07 01:40:33341 SINGLE_VALUE_TYPE(switches::kEnableSyncTabs)
[email protected]5b0ec7f2011-08-11 02:17:17342 },
343 {
[email protected]fdf4e252012-04-27 00:26:55344 "sync-tab-favicons",
345 IDS_FLAGS_SYNC_TAB_FAVICONS_NAME,
346 IDS_FLAGS_SYNC_TAB_FAVICONS_DESCRIPTION,
347 kOsAll,
348 SINGLE_VALUE_TYPE(switches::kSyncTabFavicons)
349 },
350 {
[email protected]aae9eeb12011-10-21 21:59:26351 "sync-app-notifications",
352 IDS_FLAGS_SYNC_APP_NOTIFICATIONS_NAME,
353 IDS_FLAGS_SYNC_APP_NOTIFICATIONS_DESCRIPTION,
354 kOsAll,
[email protected]0b6fba82011-11-18 01:31:11355 SINGLE_VALUE_TYPE(switches::kDisableSyncAppNotifications)
[email protected]aae9eeb12011-10-21 21:59:26356 },
357 {
[email protected]a22ebd812011-06-23 00:05:39358 "enable-smooth-scrolling", // FLAGS:RECORD_UMA
359 IDS_FLAGS_ENABLE_SMOOTH_SCROLLING_NAME,
360 IDS_FLAGS_ENABLE_SMOOTH_SCROLLING_DESCRIPTION,
361 // Can't expose the switch unless the code is compiled in.
[email protected]554b7062011-09-03 03:09:40362 // On by default for the Mac (different implementation in WebKit).
[email protected]554b7062011-09-03 03:09:40363 kOsWin | kOsLinux | kOsCrOS,
[email protected]a22ebd812011-06-23 00:05:39364 SINGLE_VALUE_TYPE(switches::kEnableSmoothScrolling)
365 },
[email protected]81a6b0b2011-06-24 17:55:40366 {
[email protected]032d5e6c2012-02-17 17:53:55367 "omnibox-inline-history-quick-provider",
368 IDS_FLAGS_OMNIBOX_INLINE_HISTORY_QUICK_PROVIDER_NAME,
369 IDS_FLAGS_OMNIBOX_INLINE_HISTORY_QUICK_PROVIDER_DESCRIPTION,
370 kOsAll,
371 MULTI_VALUE_TYPE(kOmniboxInlineHistoryQuickProviderChoices)
372 },
373 {
[email protected]7e7a28092011-12-09 22:24:55374 "enable-panels",
375 IDS_FLAGS_ENABLE_PANELS_NAME,
376 IDS_FLAGS_ENABLE_PANELS_DESCRIPTION,
[email protected]73fb1fc52011-07-09 00:06:54377 kOsAll,
[email protected]7e7a28092011-12-09 22:24:55378 SINGLE_VALUE_TYPE(switches::kEnablePanels)
[email protected]73fb1fc52011-07-09 00:06:54379 },
[email protected]e3749d12011-07-25 22:22:12380 {
[email protected]9931875b2011-11-02 00:19:48381 "disable-shortcuts-provider",
382 IDS_FLAGS_DISABLE_SHORTCUTS_PROVIDER,
383 IDS_FLAGS_DISABLE_SHORTCUTS_PROVIDER_DESCRIPTION,
[email protected]e3749d12011-07-25 22:22:12384 kOsAll,
[email protected]9931875b2011-11-02 00:19:48385 SINGLE_VALUE_TYPE(switches::kDisableShortcutsProvider)
[email protected]e3749d12011-07-25 22:22:12386 },
[email protected]80eb4262011-08-03 16:10:41387 {
[email protected]a0e4b072011-08-17 01:47:07388 "downloads-new-ui", // FLAGS:RECORD_UMA
389 IDS_FLAGS_DOWNLOADS_NEW_UI_NAME,
390 IDS_FLAGS_DOWNLOADS_NEW_UI_DESCRIPTION,
391 kOsAll,
392 SINGLE_VALUE_TYPE(switches::kDownloadsNewUI)
393 },
[email protected]b7bb44f2011-09-01 05:17:03394 {
[email protected]6474b112012-05-04 19:35:27395 "save-page-as-mhtml", // FLAGS:RECORD_UMA
396 IDS_FLAGS_SAVE_PAGE_AS_MHTML_NAME,
397 IDS_FLAGS_SAVE_PAGE_AS_MHTML_DESCRIPTION,
398 kOsMac | kOsWin | kOsLinux,
399 SINGLE_VALUE_TYPE(switches::kSavePageAsMHTML)
400 },
401 {
[email protected]b7bb44f2011-09-01 05:17:03402 "enable-autologin",
403 IDS_FLAGS_ENABLE_AUTOLOGIN_NAME,
404 IDS_FLAGS_ENABLE_AUTOLOGIN_DESCRIPTION,
405 kOsMac | kOsWin | kOsLinux,
406 SINGLE_VALUE_TYPE(switches::kEnableAutologin)
407 },
[email protected]b9841172011-09-26 23:36:09408 {
[email protected]bbadb112011-12-12 16:55:28409 "enable-http-pipelining",
410 IDS_FLAGS_ENABLE_HTTP_PIPELINING_NAME,
411 IDS_FLAGS_ENABLE_HTTP_PIPELINING_DESCRIPTION,
412 kOsAll,
413 SINGLE_VALUE_TYPE(switches::kEnableHttpPipelining)
414 },
[email protected]d411c01d2011-10-18 16:00:27415 {
[email protected]3231b612012-03-23 05:57:54416 "enable-spdy3",
417 IDS_FLAGS_ENABLE_SPDY3_NAME,
418 IDS_FLAGS_ENABLE_SPDY3_DESCRIPTION,
419 kOsAll,
420 SINGLE_VALUE_TYPE(switches::kEnableSpdy3)
421 },
422 {
[email protected]27b3fe92012-03-21 05:35:06423 "enable-async-dns",
424 IDS_FLAGS_ENABLE_ASYNC_DNS_NAME,
425 IDS_FLAGS_ENABLE_ASYNC_DNS_DESCRIPTION,
[email protected]ec9d0532012-03-21 05:55:32426 kOsWin | kOsMac | kOsLinux | kOsCrOS,
[email protected]27b3fe92012-03-21 05:35:06427 SINGLE_VALUE_TYPE(switches::kEnableAsyncDns)
428 },
429 {
[email protected]f5da41d2011-10-08 17:40:07430 "enable-video-track",
431 IDS_FLAGS_ENABLE_VIDEO_TRACK_NAME,
432 IDS_FLAGS_ENABLE_VIDEO_TRACK_DESCRIPTION,
433 kOsAll,
434 SINGLE_VALUE_TYPE(switches::kEnableVideoTrack)
435 },
[email protected]08b83362011-10-19 05:23:17436 {
[email protected]6aa03b32011-10-27 21:44:44437 "enable-media-source",
438 IDS_FLAGS_ENABLE_MEDIA_SOURCE_NAME,
439 IDS_FLAGS_ENABLE_MEDIA_SOURCE_DESCRIPTION,
[email protected]ec9d0532012-03-21 05:55:32440 kOsAll,
[email protected]6aa03b32011-10-27 21:44:44441 SINGLE_VALUE_TYPE(switches::kEnableMediaSource)
442 },
[email protected]e4e68dbb2011-11-18 01:50:22443 {
[email protected]9f5b7822012-04-18 23:39:03444 "enable-encrypted-media",
445 IDS_FLAGS_ENABLE_ENCRYPTED_MEDIA_NAME,
446 IDS_FLAGS_ENABLE_ENCRYPTED_MEDIA_DESCRIPTION,
447 kOsAll,
448 SINGLE_VALUE_TYPE(switches::kEnableEncryptedMedia)
449 },
450 {
[email protected]e4e68dbb2011-11-18 01:50:22451 "enable-pointer-lock",
452 IDS_FLAGS_ENABLE_POINTER_LOCK_NAME,
453 IDS_FLAGS_ENABLE_POINTER_LOCK_DESCRIPTION,
454 kOsAll,
455 SINGLE_VALUE_TYPE(switches::kEnablePointerLock)
456 },
[email protected]dc04be7c2012-03-15 23:57:49457#if defined(USE_ASH)
[email protected]8cc10df2011-11-03 23:57:50458 {
[email protected]57b8bb352012-01-11 05:11:46459 "aura-google-dialog-frames",
460 IDS_FLAGS_AURA_GOOGLE_DIALOG_FRAMES_NAME,
461 IDS_FLAGS_AURA_GOOGLE_DIALOG_FRAMES_DESCRIPTION,
462 kOsWin | kOsLinux | kOsCrOS,
463 SINGLE_VALUE_TYPE(ash::switches::kAuraGoogleDialogFrames)
464 },
[email protected]dc04be7c2012-03-15 23:57:49465#endif
466#if defined(USE_AURA)
[email protected]308aaa32012-03-12 13:14:50467 {
468 "aura-disable-hold-mouse-moves",
469 IDS_FLAGS_AURA_DISABLE_HOLD_MOUSE_MOVES_NAME,
470 IDS_FLAGS_AURA_DISABLE_HOLD_MOUSE_MOVES_DESCRIPTION,
471 kOsWin | kOsLinux | kOsCrOS,
472 SINGLE_VALUE_TYPE(switches::kAuraDisableHoldMouseMoves)
473 },
[email protected]eaae8b462012-01-20 22:20:39474#endif // defined(USE_AURA)
475 {
476 "enable-gamepad",
477 IDS_FLAGS_ENABLE_GAMEPAD_NAME,
478 IDS_FLAGS_ENABLE_GAMEPAD_DESCRIPTION,
479 kOsAll,
480 SINGLE_VALUE_TYPE(switches::kEnableGamepad)
481 },
[email protected]db543d322011-12-15 20:40:15482 {
483 "per-tile-painting",
484 IDS_FLAGS_PER_TILE_PAINTING_NAME,
485 IDS_FLAGS_PER_TILE_PAINTING_DESCRIPTION,
486#if defined(USE_SKIA)
[email protected]a5b1b272012-01-06 20:44:37487 kOsMac | kOsLinux | kOsCrOS,
[email protected]db543d322011-12-15 20:40:15488#else
489 0,
490#endif
491 SINGLE_VALUE_TYPE(switches::kEnablePerTilePainting)
492 },
[email protected]bf88c032011-12-22 19:05:47493 {
494 "enable-javascript-harmony",
495 IDS_FLAGS_ENABLE_JAVASCRIPT_HARMONY_NAME,
496 IDS_FLAGS_ENABLE_JAVASCRIPT_HARMONY_DESCRIPTION,
497 kOsAll,
498 SINGLE_VALUE_TYPE_AND_VALUE(switches::kJavaScriptFlags, "--harmony")
499 },
[email protected]7e7f378a2012-01-05 14:35:37500 {
[email protected]85646172012-01-09 22:45:54501 "enable-tab-browser-dragging",
502 IDS_FLAGS_ENABLE_TAB_BROWSER_DRAGGING_NAME,
503 IDS_FLAGS_ENABLE_TAB_BROWSER_DRAGGING_DESCRIPTION,
504 kOsWin,
505 SINGLE_VALUE_TYPE(switches::kTabBrowserDragging)
506 },
507 {
[email protected]068b7b52012-02-27 12:41:44508 "disable-restore-session-state",
509 IDS_FLAGS_DISABLE_RESTORE_SESSION_STATE_NAME,
510 IDS_FLAGS_DISABLE_RESTORE_SESSION_STATE_DESCRIPTION,
[email protected]7e7f378a2012-01-05 14:35:37511 kOsAll,
[email protected]068b7b52012-02-27 12:41:44512 SINGLE_VALUE_TYPE(switches::kDisableRestoreSessionState)
[email protected]7e7f378a2012-01-05 14:35:37513 },
[email protected]88864db2012-01-18 20:56:35514 {
515 "disable-software-rasterizer",
516 IDS_FLAGS_DISABLE_SOFTWARE_RASTERIZER_NAME,
517 IDS_FLAGS_DISABLE_SOFTWARE_RASTERIZER_DESCRIPTION,
518#if defined(ENABLE_SWIFTSHADER)
519 kOsAll,
520#else
521 0,
522#endif
523 SINGLE_VALUE_TYPE(switches::kDisableSoftwareRasterizer)
524 },
[email protected]15a5d722012-01-23 09:11:14525 {
526 "enable-media-stream",
527 IDS_FLAGS_MEDIA_STREAM_NAME,
528 IDS_FLAGS_MEDIA_STREAM_DESCRIPTION,
[email protected]fa82b6772012-02-20 13:19:05529 kOsAll,
[email protected]15a5d722012-01-23 09:11:14530 SINGLE_VALUE_TYPE(switches::kEnableMediaStream)
531 },
[email protected]f5ec7242012-01-27 07:15:15532 {
[email protected]8ea05a12012-05-02 09:17:47533 "enable-peer-connection",
534 IDS_FLAGS_PEER_CONNECTION_NAME,
535 IDS_FLAGS_PEER_CONNECTION_DESCRIPTION,
536 kOsAll,
537 SINGLE_VALUE_TYPE(switches::kEnablePeerConnection)
538 },
539 {
[email protected]d2edc6702012-01-30 09:13:16540 "enable-shadow-dom",
541 IDS_FLAGS_SHADOW_DOM_NAME,
542 IDS_FLAGS_SHADOW_DOM_DESCRIPTION,
543 kOsAll,
544 SINGLE_VALUE_TYPE(switches::kEnableShadowDOM)
545 },
[email protected]9860c68b2012-02-02 01:58:09546 {
[email protected]4961218f2012-02-23 10:11:07547 "enable-style-scoped",
548 IDS_FLAGS_STYLE_SCOPED_NAME,
549 IDS_FLAGS_STYLE_SCOPED_DESCRIPTION,
550 kOsAll,
551 SINGLE_VALUE_TYPE(switches::kEnableStyleScoped)
552 },
553 {
[email protected]ca7a3d792012-03-02 15:55:49554 "enable-css-regions",
555 IDS_FLAGS_CSS_REGIONS_NAME,
556 IDS_FLAGS_CSS_REGIONS_DESCRIPTION,
557 kOsAll,
558 SINGLE_VALUE_TYPE(switches::kEnableCssRegions)
559 },
560 {
[email protected]8bed69d2012-02-02 06:46:00561 "ntp-app-install-hint",
562 IDS_FLAGS_APP_INSTALL_HINT_NAME,
563 IDS_FLAGS_APP_INSTALL_HINT_DESCRIPTION,
564 kOsAll,
565 SINGLE_VALUE_TYPE(switches::kNtpAppInstallHint)
566 },
567 {
[email protected]9860c68b2012-02-02 01:58:09568 "enable-extension-activity-ui",
569 IDS_FLAGS_ENABLE_EXTENSION_ACTIVITY_UI_NAME,
570 IDS_FLAGS_ENABLE_EXTENSION_ACTIVITY_UI_DESCRIPTION,
571 kOsAll,
572 SINGLE_VALUE_TYPE(switches::kEnableExtensionActivityUI)
[email protected]8bed69d2012-02-02 06:46:00573 },
[email protected]54ae4e92012-02-16 15:19:05574 {
575 "webui-task-manager",
576 IDS_FLAGS_WEBUI_TASK_MANAGER_NAME,
577 IDS_FLAGS_WEBUI_TASK_MANAGER_DESCRIPTION,
578 kOsAll,
579 SINGLE_VALUE_TYPE(switches::kWebUITaskManager)
580 },
[email protected]156f966332012-02-29 00:03:16581 {
[email protected]3e8befc2012-03-13 01:17:03582 "disable-ntp-other-sessions-menu",
[email protected]156f966332012-02-29 00:03:16583 IDS_FLAGS_NTP_OTHER_SESSIONS_MENU_NAME,
584 IDS_FLAGS_NTP_OTHER_SESSIONS_MENU_DESCRIPTION,
585 kOsAll,
[email protected]3e8befc2012-03-13 01:17:03586 SINGLE_VALUE_TYPE(switches::kDisableNTPOtherSessionsMenu)
[email protected]156f966332012-02-29 00:03:16587 },
[email protected]dc04be7c2012-03-15 23:57:49588#if defined(USE_ASH)
[email protected]31cf1c52012-02-29 20:55:01589 {
[email protected]3cd198a22012-03-12 20:38:01590 "enable-ash-oak",
591 IDS_FLAGS_ENABLE_ASH_OAK_NAME,
592 IDS_FLAGS_ENABLE_ASH_OAK_DESCRIPTION,
593 kOsAll,
594 SINGLE_VALUE_TYPE(ash::switches::kAshEnableOak),
595 },
[email protected]31cf1c52012-02-29 20:55:01596#endif
[email protected]184ec592012-03-01 11:54:28597 {
598 "enable-devtools-experiments",
599 IDS_FLAGS_ENABLE_DEVTOOLS_EXPERIMENTS_NAME,
600 IDS_FLAGS_ENABLE_DEVTOOLS_EXPERIMENTS_DESCRIPTION,
601 kOsAll,
602 SINGLE_VALUE_TYPE(switches::kEnableDevToolsExperiments)
603 },
[email protected]76d1854e2012-03-02 23:57:44604 {
605 "enable-suggestions-ntp",
606 IDS_FLAGS_NTP_SUGGESTIONS_PAGE_NAME,
607 IDS_FLAGS_NTP_SUGGESTIONS_PAGE_DESCRIPTION,
608 kOsAll,
609 SINGLE_VALUE_TYPE(switches::kEnableSuggestionsTabPage)
610 },
[email protected]a78ef9e2012-03-21 02:49:55611 {
[email protected]0b777be22012-04-03 04:42:24612 "disable-chrome-to-mobile", // FLAGS:RECORD_UMA
613 IDS_FLAGS_DISABLE_CHROME_TO_MOBILE_NAME,
614 IDS_FLAGS_DISABLE_CHROME_TO_MOBILE_DESCRIPTION,
[email protected]a78ef9e2012-03-21 02:49:55615 kOsAll,
[email protected]0b777be22012-04-03 04:42:24616 SINGLE_VALUE_TYPE(switches::kDisableChromeToMobile)
[email protected]a78ef9e2012-03-21 02:49:55617 },
[email protected]8e466dd2012-05-04 19:16:05618#if defined(GOOGLE_CHROME_BUILD)
[email protected]a3d54252012-04-05 20:04:13619 {
[email protected]8e466dd2012-05-04 19:16:05620 "enable-asynchronous-spellchecking",
621 IDS_FLAGS_ENABLE_ASYNCHRONOUS_SPELLCHECKING,
622 IDS_FLAGS_ENABLE_ASYNCHRONOUS_SPELLCHECKING_DESCRIPTION,
623 kOsAll,
624 SINGLE_VALUE_TYPE(switches::kEnableAsynchronousSpellChecking)
[email protected]a3d54252012-04-05 20:04:13625 },
[email protected]8e466dd2012-05-04 19:16:05626#endif
[email protected]c9c73ad42012-04-18 03:35:59627 {
628 "touch-optimized-ui",
629 IDS_TOUCH_OPTIMIZED_UI_NAME,
630 IDS_TOUCH_OPTIMIZED_UI_DESCRIPTION,
631 kOsAll,
632 SINGLE_VALUE_TYPE(switches::kTouchOptimizedUI)
633 },
[email protected]8a6aaa72012-04-20 20:53:58634 {
635 "enable-touch-events",
636 IDS_ENABLE_TOUCH_EVENTS_NAME,
637 IDS_ENABLE_TOUCH_EVENTS_DESCRIPTION,
638 kOsAll,
639 SINGLE_VALUE_TYPE(switches::kEnableTouchEvents)
640 },
[email protected]0b60afa2012-04-19 17:36:39641#if defined(OS_CHROMEOS)
642 {
643 "no-discard-tabs",
644 IDS_FLAGS_NO_DISCARD_TABS_NAME,
645 IDS_FLAGS_NO_DISCARD_TABS_DESCRIPTION,
646 kOsCrOS,
647 SINGLE_VALUE_TYPE(switches::kNoDiscardTabs)
648 },
649#endif
[email protected]79be6d32012-04-24 20:47:44650 {
[email protected]f92fce5f2012-04-24 21:05:16651 "enable-sync-signin",
[email protected]79be6d32012-04-24 20:47:44652 IDS_ENABLE_SYNC_SIGNIN_NAME,
653 IDS_ENABLE_SYNC_SIGNIN_DESCRIPTION,
654 kOsAll,
655 SINGLE_VALUE_TYPE(switches::kEnableSyncSignin)
656 },
[email protected]6d947a602012-04-24 23:12:11657 {
658 "enable-platform-apps",
659 IDS_FLAGS_ENABLE_PLATFORM_APPS_NAME,
660 IDS_FLAGS_ENABLE_PLATFORM_APPS_DESCRIPTION,
661 kOsAll,
662 SINGLE_VALUE_TYPE(switches::kEnablePlatformApps)
[email protected]9a5940d2012-04-27 19:16:23663 },
664 {
665 "allow-nacl-socket-api",
666 IDS_FLAGS_ALLOW_NACL_SOCKET_API_NAME,
667 IDS_FLAGS_ALLOW_NACL_SOCKET_API_DESCRIPTION,
668 kOsAll,
669 SINGLE_VALUE_TYPE_AND_VALUE(switches::kAllowNaClSocketAPI, "*")
670 },
[email protected]85333732012-05-01 19:02:24671 {
[email protected]60673ad72012-05-02 06:16:33672 "stacked-tab-strip",
673 IDS_FLAGS_STACKED_TAB_STRIP_NAME,
674 IDS_FLAGS_STACKED_TAB_STRIP_DESCRIPTION,
675 kOsWin,
676 SINGLE_VALUE_TYPE(switches::kEnableStackedTabStrip)
677 },
678 {
[email protected]85333732012-05-01 19:02:24679 "default-device-scale-factor",
680 IDS_FLAGS_FORCE_HIGH_DPI_NAME,
681 IDS_FLAGS_FORCE_HIGH_DPI_DESCRIPTION,
682 kOsCrOS,
683 SINGLE_VALUE_TYPE_AND_VALUE(switches::kDefaultDeviceScaleFactor, "2")
684 },
[email protected]190349fd2012-05-02 00:10:47685#if defined(OS_CHROMEOS)
686 {
687 "allow-touchpad-three-finger-click",
688 IDS_FLAGS_ALLOW_TOUCHPAD_THREE_FINGER_CLICK_NAME,
689 IDS_FLAGS_ALLOW_TOUCHPAD_THREE_FINGER_CLICK_DESCRIPTION,
690 kOsCrOS,
691 SINGLE_VALUE_TYPE(switches::kEnableTouchpadThreeFingerClick)
692 },
693#endif
[email protected]aab64e02012-05-03 19:24:16694 {
695 "enable-client-oauth-signin",
696 IDS_FLAGS_ENABLE_CLIENT_OAUTH_SIGNIN_NAME,
697 IDS_FLAGS_ENABLE_CLIENT_OAUTH_SIGNIN_DESCRIPTION,
698 kOsMac | kOsWin | kOsLinux,
699 SINGLE_VALUE_TYPE(switches::kEnableClientOAuthSignin)
700 },
[email protected]a0e4b072011-08-17 01:47:07701};
[email protected]ad2a3ded2010-08-27 13:19:05702
[email protected]a314ee5a2010-10-26 21:23:28703const Experiment* experiments = kExperiments;
704size_t num_experiments = arraysize(kExperiments);
705
[email protected]e2ddbc92010-10-15 20:02:07706// Stores and encapsulates the little state that about:flags has.
707class FlagsState {
708 public:
709 FlagsState() : needs_restart_(false) {}
710 void ConvertFlagsToSwitches(PrefService* prefs, CommandLine* command_line);
711 bool IsRestartNeededToCommitChanges();
712 void SetExperimentEnabled(
[email protected]a314ee5a2010-10-26 21:23:28713 PrefService* prefs, const std::string& internal_name, bool enable);
[email protected]e2ddbc92010-10-15 20:02:07714 void RemoveFlagsSwitches(
715 std::map<std::string, CommandLine::StringType>* switch_list);
716 void reset();
717
718 // Returns the singleton instance of this class
[email protected]8e8bb6d2010-12-13 08:18:55719 static FlagsState* GetInstance() {
[email protected]e2ddbc92010-10-15 20:02:07720 return Singleton<FlagsState>::get();
721 }
722
723 private:
724 bool needs_restart_;
[email protected]a82744532011-02-11 16:15:53725 std::map<std::string, std::string> flags_switches_;
[email protected]e2ddbc92010-10-15 20:02:07726
727 DISALLOW_COPY_AND_ASSIGN(FlagsState);
728};
729
[email protected]c7b7800a2010-10-07 18:51:35730// Extracts the list of enabled lab experiments from preferences and stores them
[email protected]ad2a3ded2010-08-27 13:19:05731// in a set.
[email protected]1a47d7e2010-10-15 00:37:24732void GetEnabledFlags(const PrefService* prefs, std::set<std::string>* result) {
[email protected]ad2a3ded2010-08-27 13:19:05733 const ListValue* enabled_experiments = prefs->GetList(
734 prefs::kEnabledLabsExperiments);
735 if (!enabled_experiments)
736 return;
737
738 for (ListValue::const_iterator it = enabled_experiments->begin();
739 it != enabled_experiments->end();
740 ++it) {
741 std::string experiment_name;
742 if (!(*it)->GetAsString(&experiment_name)) {
743 LOG(WARNING) << "Invalid entry in " << prefs::kEnabledLabsExperiments;
744 continue;
745 }
746 result->insert(experiment_name);
747 }
748}
749
750// Takes a set of enabled lab experiments
[email protected]1a47d7e2010-10-15 00:37:24751void SetEnabledFlags(
[email protected]ad2a3ded2010-08-27 13:19:05752 PrefService* prefs, const std::set<std::string>& enabled_experiments) {
[email protected]1bc78422011-03-31 08:41:38753 ListPrefUpdate update(prefs, prefs::kEnabledLabsExperiments);
754 ListValue* experiments_list = update.Get();
[email protected]ad2a3ded2010-08-27 13:19:05755
756 experiments_list->Clear();
757 for (std::set<std::string>::const_iterator it = enabled_experiments.begin();
758 it != enabled_experiments.end();
759 ++it) {
760 experiments_list->Append(new StringValue(*it));
761 }
762}
763
[email protected]8a6ff28d2010-12-02 16:35:19764// Returns the name used in prefs for the choice at the specified index.
765std::string NameForChoice(const Experiment& e, int index) {
[email protected]2ce9c89752011-02-25 18:24:34766 DCHECK_EQ(Experiment::MULTI_VALUE, e.type);
767 DCHECK_LT(index, e.num_choices);
[email protected]8a6ff28d2010-12-02 16:35:19768 return std::string(e.internal_name) + about_flags::testing::kMultiSeparator +
769 base::IntToString(index);
770}
771
772// Adds the internal names for the specified experiment to |names|.
773void AddInternalName(const Experiment& e, std::set<std::string>* names) {
774 if (e.type == Experiment::SINGLE_VALUE) {
775 names->insert(e.internal_name);
776 } else {
[email protected]2ce9c89752011-02-25 18:24:34777 DCHECK_EQ(Experiment::MULTI_VALUE, e.type);
[email protected]8a6ff28d2010-12-02 16:35:19778 for (int i = 0; i < e.num_choices; ++i)
779 names->insert(NameForChoice(e, i));
780 }
781}
782
[email protected]28e35af2011-02-09 12:56:22783// Confirms that an experiment is valid, used in a DCHECK in
784// SanitizeList below.
785bool ValidateExperiment(const Experiment& e) {
786 switch (e.type) {
787 case Experiment::SINGLE_VALUE:
788 DCHECK_EQ(0, e.num_choices);
789 DCHECK(!e.choices);
790 break;
791 case Experiment::MULTI_VALUE:
792 DCHECK_GT(e.num_choices, 0);
793 DCHECK(e.choices);
[email protected]a82744532011-02-11 16:15:53794 DCHECK(e.choices[0].command_line_switch);
795 DCHECK_EQ('\0', e.choices[0].command_line_switch[0]);
[email protected]28e35af2011-02-09 12:56:22796 break;
797 default:
798 NOTREACHED();
799 }
800 return true;
801}
802
[email protected]ad2a3ded2010-08-27 13:19:05803// Removes all experiments from prefs::kEnabledLabsExperiments that are
804// unknown, to prevent this list to become very long as experiments are added
805// and removed.
806void SanitizeList(PrefService* prefs) {
807 std::set<std::string> known_experiments;
[email protected]28e35af2011-02-09 12:56:22808 for (size_t i = 0; i < num_experiments; ++i) {
809 DCHECK(ValidateExperiment(experiments[i]));
[email protected]8a6ff28d2010-12-02 16:35:19810 AddInternalName(experiments[i], &known_experiments);
[email protected]28e35af2011-02-09 12:56:22811 }
[email protected]ad2a3ded2010-08-27 13:19:05812
813 std::set<std::string> enabled_experiments;
[email protected]1a47d7e2010-10-15 00:37:24814 GetEnabledFlags(prefs, &enabled_experiments);
[email protected]ad2a3ded2010-08-27 13:19:05815
816 std::set<std::string> new_enabled_experiments;
817 std::set_intersection(
818 known_experiments.begin(), known_experiments.end(),
819 enabled_experiments.begin(), enabled_experiments.end(),
820 std::inserter(new_enabled_experiments, new_enabled_experiments.begin()));
821
[email protected]1a47d7e2010-10-15 00:37:24822 SetEnabledFlags(prefs, new_enabled_experiments);
[email protected]ad2a3ded2010-08-27 13:19:05823}
824
[email protected]1a47d7e2010-10-15 00:37:24825void GetSanitizedEnabledFlags(
[email protected]ad2a3ded2010-08-27 13:19:05826 PrefService* prefs, std::set<std::string>* result) {
827 SanitizeList(prefs);
[email protected]1a47d7e2010-10-15 00:37:24828 GetEnabledFlags(prefs, result);
[email protected]ad2a3ded2010-08-27 13:19:05829}
830
[email protected]a314ee5a2010-10-26 21:23:28831// Variant of GetSanitizedEnabledFlags that also removes any flags that aren't
832// enabled on the current platform.
833void GetSanitizedEnabledFlagsForCurrentPlatform(
834 PrefService* prefs, std::set<std::string>* result) {
835 GetSanitizedEnabledFlags(prefs, result);
836
837 // Filter out any experiments that aren't enabled on the current platform. We
838 // don't remove these from prefs else syncing to a platform with a different
839 // set of experiments would be lossy.
840 std::set<std::string> platform_experiments;
841 int current_platform = GetCurrentPlatform();
842 for (size_t i = 0; i < num_experiments; ++i) {
843 if (experiments[i].supported_platforms & current_platform)
[email protected]8a6ff28d2010-12-02 16:35:19844 AddInternalName(experiments[i], &platform_experiments);
[email protected]a314ee5a2010-10-26 21:23:28845 }
846
847 std::set<std::string> new_enabled_experiments;
848 std::set_intersection(
849 platform_experiments.begin(), platform_experiments.end(),
850 result->begin(), result->end(),
851 std::inserter(new_enabled_experiments, new_enabled_experiments.begin()));
852
853 result->swap(new_enabled_experiments);
[email protected]ad2a3ded2010-08-27 13:19:05854}
855
[email protected]8a6ff28d2010-12-02 16:35:19856// Returns the Value representing the choice data in the specified experiment.
[email protected]8a6ff28d2010-12-02 16:35:19857Value* CreateChoiceData(const Experiment& experiment,
[email protected]28e35af2011-02-09 12:56:22858 const std::set<std::string>& enabled_experiments) {
[email protected]2ce9c89752011-02-25 18:24:34859 DCHECK_EQ(Experiment::MULTI_VALUE, experiment.type);
[email protected]8a6ff28d2010-12-02 16:35:19860 ListValue* result = new ListValue;
861 for (int i = 0; i < experiment.num_choices; ++i) {
862 const Experiment::Choice& choice = experiment.choices[i];
863 DictionaryValue* value = new DictionaryValue;
864 std::string name = NameForChoice(experiment, i);
865 value->SetString("description",
866 l10n_util::GetStringUTF16(choice.description_id));
867 value->SetString("internal_name", name);
[email protected]28e35af2011-02-09 12:56:22868 value->SetBoolean("selected", enabled_experiments.count(name) > 0);
[email protected]8a6ff28d2010-12-02 16:35:19869 result->Append(value);
870 }
871 return result;
872}
873
[email protected]e2ddbc92010-10-15 20:02:07874} // namespace
875
[email protected]1a47d7e2010-10-15 00:37:24876void ConvertFlagsToSwitches(PrefService* prefs, CommandLine* command_line) {
[email protected]8e8bb6d2010-12-13 08:18:55877 FlagsState::GetInstance()->ConvertFlagsToSwitches(prefs, command_line);
[email protected]ad2a3ded2010-08-27 13:19:05878}
879
[email protected]1a47d7e2010-10-15 00:37:24880ListValue* GetFlagsExperimentsData(PrefService* prefs) {
[email protected]ad2a3ded2010-08-27 13:19:05881 std::set<std::string> enabled_experiments;
[email protected]1a47d7e2010-10-15 00:37:24882 GetSanitizedEnabledFlags(prefs, &enabled_experiments);
[email protected]ad2a3ded2010-08-27 13:19:05883
884 int current_platform = GetCurrentPlatform();
885
886 ListValue* experiments_data = new ListValue();
[email protected]a314ee5a2010-10-26 21:23:28887 for (size_t i = 0; i < num_experiments; ++i) {
888 const Experiment& experiment = experiments[i];
[email protected]ad2a3ded2010-08-27 13:19:05889
890 DictionaryValue* data = new DictionaryValue();
891 data->SetString("internal_name", experiment.internal_name);
892 data->SetString("name",
893 l10n_util::GetStringUTF16(experiment.visible_name_id));
894 data->SetString("description",
895 l10n_util::GetStringUTF16(
896 experiment.visible_description_id));
[email protected]cc3e2052011-12-20 01:01:40897 bool supported = !!(experiment.supported_platforms & current_platform);
898 data->SetBoolean("supported", supported);
899
900 ListValue* supported_platforms = new ListValue();
901 AddOsStrings(experiment.supported_platforms, supported_platforms);
902 data->Set("supported_platforms", supported_platforms);
[email protected]ad2a3ded2010-08-27 13:19:05903
[email protected]28e35af2011-02-09 12:56:22904 switch (experiment.type) {
905 case Experiment::SINGLE_VALUE:
906 data->SetBoolean(
907 "enabled",
908 enabled_experiments.count(experiment.internal_name) > 0);
909 break;
910 case Experiment::MULTI_VALUE:
911 data->Set("choices", CreateChoiceData(experiment, enabled_experiments));
912 break;
913 default:
914 NOTREACHED();
[email protected]8a6ff28d2010-12-02 16:35:19915 }
916
[email protected]ad2a3ded2010-08-27 13:19:05917 experiments_data->Append(data);
918 }
919 return experiments_data;
920}
921
[email protected]ad2a3ded2010-08-27 13:19:05922bool IsRestartNeededToCommitChanges() {
[email protected]8e8bb6d2010-12-13 08:18:55923 return FlagsState::GetInstance()->IsRestartNeededToCommitChanges();
[email protected]ad2a3ded2010-08-27 13:19:05924}
925
926void SetExperimentEnabled(
[email protected]c7b7800a2010-10-07 18:51:35927 PrefService* prefs, const std::string& internal_name, bool enable) {
[email protected]8e8bb6d2010-12-13 08:18:55928 FlagsState::GetInstance()->SetExperimentEnabled(prefs, internal_name, enable);
[email protected]e2ddbc92010-10-15 20:02:07929}
930
931void RemoveFlagsSwitches(
932 std::map<std::string, CommandLine::StringType>* switch_list) {
[email protected]8e8bb6d2010-12-13 08:18:55933 FlagsState::GetInstance()->RemoveFlagsSwitches(switch_list);
[email protected]e2ddbc92010-10-15 20:02:07934}
935
[email protected]a314ee5a2010-10-26 21:23:28936int GetCurrentPlatform() {
937#if defined(OS_MACOSX)
938 return kOsMac;
939#elif defined(OS_WIN)
940 return kOsWin;
941#elif defined(OS_CHROMEOS) // Needs to be before the OS_LINUX check.
942 return kOsCrOS;
[email protected]c92f4ed2011-10-21 19:50:21943#elif defined(OS_LINUX) || defined(OS_OPENBSD)
[email protected]a314ee5a2010-10-26 21:23:28944 return kOsLinux;
[email protected]9c7453d2012-01-21 00:45:40945#elif defined(OS_ANDROID)
946 return kOsAndroid;
[email protected]a314ee5a2010-10-26 21:23:28947#else
948#error Unknown platform
949#endif
950}
951
[email protected]4bc5050c2010-11-18 17:55:54952void RecordUMAStatistics(const PrefService* prefs) {
953 std::set<std::string> flags;
954 GetEnabledFlags(prefs, &flags);
955 for (std::set<std::string>::iterator it = flags.begin(); it != flags.end();
956 ++it) {
957 std::string action("AboutFlags_");
958 action += *it;
[email protected]7f6f44c2011-12-14 13:23:38959 content::RecordComputedAction(action);
[email protected]4bc5050c2010-11-18 17:55:54960 }
961 // Since flag metrics are recorded every startup, add a tick so that the
962 // stats can be made meaningful.
963 if (flags.size())
[email protected]7f6f44c2011-12-14 13:23:38964 content::RecordAction(UserMetricsAction("AboutFlags_StartupTick"));
965 content::RecordAction(UserMetricsAction("StartupTick"));
[email protected]4bc5050c2010-11-18 17:55:54966}
967
[email protected]e2ddbc92010-10-15 20:02:07968//////////////////////////////////////////////////////////////////////////////
969// FlagsState implementation.
970
971namespace {
972
973void FlagsState::ConvertFlagsToSwitches(
974 PrefService* prefs, CommandLine* command_line) {
[email protected]e2ddbc92010-10-15 20:02:07975 if (command_line->HasSwitch(switches::kNoExperiments))
976 return;
977
978 std::set<std::string> enabled_experiments;
[email protected]ba8164242010-11-16 21:31:00979
[email protected]a314ee5a2010-10-26 21:23:28980 GetSanitizedEnabledFlagsForCurrentPlatform(prefs, &enabled_experiments);
[email protected]e2ddbc92010-10-15 20:02:07981
[email protected]a82744532011-02-11 16:15:53982 typedef std::map<std::string, std::pair<std::string, std::string> >
983 NameToSwitchAndValueMap;
984 NameToSwitchAndValueMap name_to_switch_map;
[email protected]8a6ff28d2010-12-02 16:35:19985 for (size_t i = 0; i < num_experiments; ++i) {
986 const Experiment& e = experiments[i];
987 if (e.type == Experiment::SINGLE_VALUE) {
[email protected]a82744532011-02-11 16:15:53988 name_to_switch_map[e.internal_name] =
989 std::pair<std::string, std::string>(e.command_line_switch,
990 e.command_line_value);
[email protected]8a6ff28d2010-12-02 16:35:19991 } else {
992 for (int j = 0; j < e.num_choices; ++j)
[email protected]a82744532011-02-11 16:15:53993 name_to_switch_map[NameForChoice(e, j)] =
994 std::pair<std::string, std::string>(
995 e.choices[j].command_line_switch,
996 e.choices[j].command_line_value);
[email protected]8a6ff28d2010-12-02 16:35:19997 }
998 }
[email protected]e2ddbc92010-10-15 20:02:07999
1000 command_line->AppendSwitch(switches::kFlagSwitchesBegin);
[email protected]a82744532011-02-11 16:15:531001 flags_switches_.insert(
1002 std::pair<std::string, std::string>(switches::kFlagSwitchesBegin,
1003 std::string()));
[email protected]e2ddbc92010-10-15 20:02:071004 for (std::set<std::string>::iterator it = enabled_experiments.begin();
1005 it != enabled_experiments.end();
1006 ++it) {
1007 const std::string& experiment_name = *it;
[email protected]a82744532011-02-11 16:15:531008 NameToSwitchAndValueMap::const_iterator name_to_switch_it =
[email protected]8a6ff28d2010-12-02 16:35:191009 name_to_switch_map.find(experiment_name);
1010 if (name_to_switch_it == name_to_switch_map.end()) {
1011 NOTREACHED();
[email protected]e2ddbc92010-10-15 20:02:071012 continue;
[email protected]8a6ff28d2010-12-02 16:35:191013 }
[email protected]e2ddbc92010-10-15 20:02:071014
[email protected]a82744532011-02-11 16:15:531015 const std::pair<std::string, std::string>&
1016 switch_and_value_pair = name_to_switch_it->second;
1017
1018 command_line->AppendSwitchASCII(switch_and_value_pair.first,
1019 switch_and_value_pair.second);
1020 flags_switches_[switch_and_value_pair.first] = switch_and_value_pair.second;
[email protected]e2ddbc92010-10-15 20:02:071021 }
1022 command_line->AppendSwitch(switches::kFlagSwitchesEnd);
[email protected]a82744532011-02-11 16:15:531023 flags_switches_.insert(
1024 std::pair<std::string, std::string>(switches::kFlagSwitchesEnd,
1025 std::string()));
[email protected]e2ddbc92010-10-15 20:02:071026}
1027
1028bool FlagsState::IsRestartNeededToCommitChanges() {
1029 return needs_restart_;
1030}
1031
1032void FlagsState::SetExperimentEnabled(
1033 PrefService* prefs, const std::string& internal_name, bool enable) {
[email protected]ad2a3ded2010-08-27 13:19:051034 needs_restart_ = true;
1035
[email protected]8a6ff28d2010-12-02 16:35:191036 size_t at_index = internal_name.find(about_flags::testing::kMultiSeparator);
1037 if (at_index != std::string::npos) {
1038 DCHECK(enable);
1039 // We're being asked to enable a multi-choice experiment. Disable the
1040 // currently selected choice.
1041 DCHECK_NE(at_index, 0u);
[email protected]28e35af2011-02-09 12:56:221042 const std::string experiment_name = internal_name.substr(0, at_index);
1043 SetExperimentEnabled(prefs, experiment_name, false);
[email protected]8a6ff28d2010-12-02 16:35:191044
[email protected]28e35af2011-02-09 12:56:221045 // And enable the new choice, if it is not the default first choice.
1046 if (internal_name != experiment_name + "@0") {
1047 std::set<std::string> enabled_experiments;
1048 GetSanitizedEnabledFlags(prefs, &enabled_experiments);
1049 enabled_experiments.insert(internal_name);
1050 SetEnabledFlags(prefs, enabled_experiments);
1051 }
[email protected]8a6ff28d2010-12-02 16:35:191052 return;
1053 }
1054
[email protected]ad2a3ded2010-08-27 13:19:051055 std::set<std::string> enabled_experiments;
[email protected]1a47d7e2010-10-15 00:37:241056 GetSanitizedEnabledFlags(prefs, &enabled_experiments);
[email protected]ad2a3ded2010-08-27 13:19:051057
[email protected]8a6ff28d2010-12-02 16:35:191058 const Experiment* e = NULL;
1059 for (size_t i = 0; i < num_experiments; ++i) {
1060 if (experiments[i].internal_name == internal_name) {
1061 e = experiments + i;
1062 break;
1063 }
1064 }
1065 DCHECK(e);
1066
1067 if (e->type == Experiment::SINGLE_VALUE) {
[email protected]8a2713682011-08-19 10:36:591068 if (enable)
[email protected]8a6ff28d2010-12-02 16:35:191069 enabled_experiments.insert(internal_name);
[email protected]8a2713682011-08-19 10:36:591070 else
[email protected]8a6ff28d2010-12-02 16:35:191071 enabled_experiments.erase(internal_name);
1072 } else {
1073 if (enable) {
1074 // Enable the first choice.
1075 enabled_experiments.insert(NameForChoice(*e, 0));
1076 } else {
1077 // Find the currently enabled choice and disable it.
1078 for (int i = 0; i < e->num_choices; ++i) {
1079 std::string choice_name = NameForChoice(*e, i);
1080 if (enabled_experiments.find(choice_name) !=
1081 enabled_experiments.end()) {
1082 enabled_experiments.erase(choice_name);
1083 // Continue on just in case there's a bug and more than one
1084 // experiment for this choice was enabled.
1085 }
1086 }
1087 }
1088 }
[email protected]ad2a3ded2010-08-27 13:19:051089
[email protected]1a47d7e2010-10-15 00:37:241090 SetEnabledFlags(prefs, enabled_experiments);
[email protected]ad2a3ded2010-08-27 13:19:051091}
1092
[email protected]e2ddbc92010-10-15 20:02:071093void FlagsState::RemoveFlagsSwitches(
1094 std::map<std::string, CommandLine::StringType>* switch_list) {
[email protected]a82744532011-02-11 16:15:531095 for (std::map<std::string, std::string>::const_iterator
1096 it = flags_switches_.begin(); it != flags_switches_.end(); ++it) {
1097 switch_list->erase(it->first);
[email protected]e2ddbc92010-10-15 20:02:071098 }
1099}
1100
1101void FlagsState::reset() {
1102 needs_restart_ = false;
1103 flags_switches_.clear();
1104}
1105
[email protected]38e46812011-05-09 20:49:221106} // namespace
[email protected]e2ddbc92010-10-15 20:02:071107
1108namespace testing {
[email protected]8a6ff28d2010-12-02 16:35:191109
1110// WARNING: '@' is also used in the html file. If you update this constant you
1111// also need to update the html file.
1112const char kMultiSeparator[] = "@";
1113
[email protected]e2ddbc92010-10-15 20:02:071114void ClearState() {
[email protected]8e8bb6d2010-12-13 08:18:551115 FlagsState::GetInstance()->reset();
[email protected]e2ddbc92010-10-15 20:02:071116}
[email protected]a314ee5a2010-10-26 21:23:281117
1118void SetExperiments(const Experiment* e, size_t count) {
1119 if (!e) {
1120 experiments = kExperiments;
1121 num_experiments = arraysize(kExperiments);
1122 } else {
1123 experiments = e;
1124 num_experiments = count;
1125 }
1126}
1127
[email protected]8a6ff28d2010-12-02 16:35:191128const Experiment* GetExperiments(size_t* count) {
1129 *count = num_experiments;
1130 return experiments;
1131}
1132
[email protected]e2ddbc92010-10-15 20:02:071133} // namespace testing
1134
[email protected]1a47d7e2010-10-15 00:37:241135} // namespace about_flags