// Activate (make foreground) myself on launch.  Helpful when Chrome
// is launched on the command line (e.g. by Selenium).  Only needed on Mac.
kActivateOnLaunch              = "activate-on-launch";
 
// By default, file:// URIs cannot read other file:// URIs. This is an
// override for developers who need the old behavior for testing.
kAllowFileAccessFromFiles      = "allow-file-access-from-files";
 
// Allows debugging of sandboxed processes (see zygote_main_linux.cc).
kAllowSandboxDebugging         = "allow-sandbox-debugging";
 
// Enable web inspector for all windows, even if they're part of the browser.
// Allows us to use our dev tools to debug browser windows itself.
kAlwaysEnableDevTools          = "always-enable-dev-tools";
 
// Specifies that the associated value should be launched in "application" mode.
kApp                           = "app";
 
// Specifies that the extension-app with the specified id should be launched
// according to its configuration.
kAppId                         = "app-id";
 
// Lacks meaning with out kApp. Causes the specified app to be launched in an
// panel window.
kAppLaunchAsPanel              = "app-launch-as-panel";
 
// Makes the app launcher popup when a new tab is created.
kAppsPanel                     = "apps-panel";
 
// The URL to use for the gallery link in the app launcher.
kAppsGalleryURL                = "apps-gallery-url";
 
// Disable throbber for extension apps.
kAppsNoThrob                   = "apps-no-throb";
 
// Whether to display the "Debug" link for app launch behavior.
kAppsDebug      = "apps-debug";
 
// Authentication white list for servers
kAuthServerWhitelist           = "auth-server-whitelist";
 
// The value of this switch tells the app to listen for and broadcast
// automation-related messages on IPC channel with the given ID.
kAutomationClientChannelID     = "automation-channel";
 
// Causes the browser process to throw an assertion on startup.
kBrowserAssertTest             = "assert-test";
 
// Causes the browser process to crash on startup.
kBrowserCrashTest              = "crash-test";
 
// Path to the exe to run for the renderer and plugin subprocesses.
kBrowserSubprocessPath         = "browser-subprocess-path";
 
// Run Chrome in Chrome Frame mode. This means that Chrome expects to be run
// as a dependent process of the Chrome Frame plugin.
kChromeFrame                   = "chrome-frame";
 
// The unique id to be used for this cloud print proxy instance.
kCloudPrintProxyId             = "cloud-print-proxy-id";
 
// The URL of the cloud print service to use, overrides any value
// stored in preferences, and the default.  Only used if the cloud
// print service has been enabled (see enable-cloud-print).
kCloudPrintServiceURL          = "cloud-print-service";
 
// The Country we should use.  This is normally obtained from the operating
// system during first run and cached in the preferences afterwards.  This is a
// string value, the 2 letter code from ISO 3166-1.
kCountry                       = "country";
 
// Enables support to debug printing subsystem.
kDebugPrint                    = "debug-print";
 
// Triggers a pletora of diagnostic modes.
kDiagnostics                   = "diagnostics";
 
// Disables the alternate window station for the renderer.
kDisableAltWinstation          = "disable-winsta";
 
// Disable the ApplicationCache.
kDisableApplicationCache       = "disable-application-cache";
 
// Replaces the audio IPC layer for  and  with a mock audio
// device, useful when using remote desktop or machines without sound cards.
// This is temporary until we fix the underlying problem.
//
// TODO(scherkus): remove --disable-audio when we have a proper fallback
// mechanism.
kDisableAudio                  = "disable-audio";
 
// Disable CNAME lookup of the host when generating the Kerberos SPN for a
// Negotiate challenge. See HttpAuthHandlerNegotiate::CreateSPN
// for more background.
kDisableAuthNegotiateCnameLookup =
    "disable-auth-negotiate-cname-lookup";
 
// Disable limits on the number of backing stores. Can prevent blinking for
// users with many windows/tabs and lots of memory.
kDisableBackingStoreLimit      = "disable-backing-store-limit";
 
// Disable support for cached byte-ranges.
kDisableByteRangeSupport       = "disable-byte-range-support";
 
// Disables the custom JumpList on Windows 7.
kDisableCustomJumpList         = "disable-custom-jumplist";
 
// Disables HTML5 DB support.
kDisableDatabases              = "disable-databases";
 
// Disables desktop notifications (default enabled on windows).
kDisableDesktopNotifications   = "disable-desktop-notifications";
 
// Browser flag to disable the web inspector for all renderers.
kDisableDevTools               = "disable-dev-tools";
 
// Disable extensions.
kDisableExtensions             = "disable-extensions";
 
// Disable checking for user opt-in for extensions that want to inject script
// into file URLs (ie, always allow it). This is used during automated testing.
kDisableExtensionsFileAccessCheck =
    "disable-extensions-file-access-check";
 
// Suppresses support for the Geolocation javascript API.
kDisableGeolocation            = "disable-geolocation";
 
// Suppresses hang monitor dialogs in renderer processes.
kDisableHangMonitor            = "disable-hang-monitor";
 
// Disable the internal Flash Player.
kDisableInternalFlash          = "disable-internal-flash";
 
// Don't resolve hostnames to IPv6 addresses. This can be used when debugging
// issues relating to IPv6, but shouldn't otherwise be needed. Be sure to
// file bugs if something isn't working properly in the presence of IPv6.
// This flag can be overidden by the "enable-ipv6" flag.
kDisableIPv6                   = "disable-ipv6";
 
// Don't execute JavaScript (browser JS like the new tab page still runs).
kDisableJavaScript             = "disable-javascript";
 
// Prevent Java from running.
kDisableJava                   = "disable-java";
 
// Disable LocalStorage.
kDisableLocalStorage           = "disable-local-storage";
 
// Force logging to be disabled.  Logging is enabled by default in debug
// builds.
kDisableLogging                = "disable-logging";
 
// Whether we should prevent the new tab page from showing the first run
// notification.
kDisableNewTabFirstRun         = "disable-new-tab-first-run";
 
// Prevent plugins from running.
kDisablePlugins                = "disable-plugins";
 
// Disable pop-up blocking.
kDisablePopupBlocking          = "disable-popup-blocking";
 
// Normally when the user attempts to navigate to a page that was the result of
// a post we prompt to make sure they want to. This switch may be used to
// disable that check. This switch is used during automated testing.
kDisablePromptOnRepost         = "disable-prompt-on-repost";
 
// Disable remote web font support. SVG font should always work whether
// this option is specified or not.
kDisableRemoteFonts            = "disable-remote-fonts";
 
// Turns off the accessibility in the renderer.
kDisableRendererAccessibility  = "disable-renderer-accessibility";
 
// Disable session storage.
kDisableSessionStorage         = "disable-session-storage";
 
// Enable shared workers. Functionality not yet complete.
kDisableSharedWorkers          = "disable-shared-workers";
 
// Disable site-specific tailoring to compatibility issues in WebKit.
kDisableSiteSpecificQuirks     = "disable-site-specific-quirks";
 
// Disable syncing browser data to a Google Account.
kDisableSync                   = "disable-sync";
 
// Disable syncing of autofill.
kDisableSyncAutofill           = "disable-sync-autofill";
 
// Disable syncing of bookmarks.
kDisableSyncBookmarks          = "disable-sync-bookmarks";
 
// Disable syncing of extensions.
kDisableSyncExtensions         = "disable-sync-extensions";
 
// Disable syncing of passwords.
kDisableSyncPasswords          = "disable-sync-passwords";
 
// Disable syncing of preferences.
kDisableSyncPreferences        = "disable-sync-preferences";
 
// Disable syncing of themes.
kDisableSyncThemes             = "disable-sync-themes";
 
// Disable syncing of typed urls.
kDisableSyncTypedUrls          = "disable-sync-typed-urls";
 
// Enables the backend service for web resources, used in the new tab page for
// loading tips and recommendations from a JSON feed.
kDisableWebResources           = "disable-web-resources";
 
// Don't enforce the same-origin policy.  (Used by people testing their sites.)
kDisableWebSecurity            = "disable-web-security";
 
// Disable Web Sockets support.
kDisableWebSockets             = "disable-web-sockets";
 
// Use a specific disk cache location, rather than one derived from the
// UserDatadir.
kDiskCacheDir                  = "disk-cache-dir";
 
// Forces the maximum disk space to be used by the disk cache, in bytes.
kDiskCacheSize                 = "disk-cache-size";
 
kDnsLogDetails                 = "dns-log-details";
 
// Disables prefetching of DNS information.
kDnsPrefetchDisable            = "dns-prefetch-disable";
 
// Specifies if the dom_automation_controller_ needs to be bound in the
// renderer. This binding happens on per-frame basis and hence can potentially
// be a performance bottleneck. One should only enable it when automating
// dom based tests.
kDomAutomationController       = "dom-automation";
 
// Dump any accumualted histograms to the log when browser terminates (requires
// logging to be enabled to really do anything).  Used by developers and test
// scripts.
kDumpHistogramsOnExit          = "dump-histograms-on-exit";
 
// Enable gpu-accelerated compositing.
kEnableAcceleratedCompositing  = "enable-accelerated-compositing";
 
// Enables AeroPeek for each tab. (This switch only works on Windows 7).
kEnableAeroPeekTabs            = "enable-aero-peek-tabs";
 
// Enable experimental extension apps.
kEnableApps                    = "enable-apps";
 
// Enable the inclusion of non-standard ports when generating the Kerberos SPN
// in response to a Negotiate challenge. See HttpAuthHandlerNegotiate::CreateSPN
// for more background.
kEnableAuthNegotiatePort       = "enable-auth-negotiate-port";
 
// Enables the benchmarking extensions.
kEnableBenchmarking            = "enable-benchmarking";
 
// This applies only when the process type is "service". Enables the
// Chromoting Host Process within the service process.
kEnableChromoting              = "enable-chromoting";
 
// This applies only when the process type is "service". Enables the
// Cloud Print Proxy component within the service process.
kEnableCloudPrintProxy         = "enable-cloud-print-proxy";
 
// Enables the Cloud Print dialog hosting code.
kEnableCloudPrint              = "enable-cloud-print";
 
// Enables extension APIs that are in development.
kEnableExperimentalExtensionApis =
    "enable-experimental-extension-apis";
 
// Enable experimental WebGL support.
kEnableExperimentalWebGL       = "enable-webgl";
 
// Enable experimental timeline API.
kEnableExtensionTimelineApi    = "enable-extension-timeline-api";
 
// Enable extension toolstrips (deprecated API - will be removed).
kEnableExtensionToolstrips     = "enable-extension-toolstrips";
 
// Enable the fastback page cache.
kEnableFastback                = "enable-fastback";
 
// By default, cookies are not allowed on file://. They are needed for
// testing, for example page cycler and layout tests.  See bug 1157243.
kEnableFileCookies             = "enable-file-cookies";
 
// Enable the Indexed Database API.
kEnableIndexedDatabase         = "enable-indexed-database";
 
// Use the InMemoryURLIndex to back the HistoryURLProvider for autocomplete
// results.  If not set, defaults to using the InMemoryDatabase.
kEnableInMemoryURLIndex        = "enable-in-memory-url-index";
 
// Enable IPv6 support, even if probes suggest that it may not be fully
// supported.  Some probes may require internet connections, and this flag will
// allow support independent of application testing.
// This flag overrides "disable-ipv6" which appears elswhere in this file.
kEnableIPv6                    = "enable-ipv6";
 
// Enable the GLSL translator.
kEnableGLSLTranslator          = "enable-glsl-translator";
 
// Enable the GPU plugin and Pepper 3D rendering.
kEnableGPUPlugin               = "enable-gpu-plugin";
 
// Enable experimental GPU rendering for backing store and video.
kEnableGPURendering            = "enable-gpu-rendering";
 
// Force logging to be enabled.  Logging is disabled by default in release
// builds.
kEnableLogging                 = "enable-logging";
 
// On Windows, converts the page to the currently-installed monitor profile.
// This does NOT enable color management for images. The source is still
// assumed to be sRGB.
kEnableMonitorProfile          = "enable-monitor-profile";
 
// Runs the Native Client inside the renderer process and enables GPU plugin
// (internally adds kInternalNaCl and lEnableGpuPlugin to the command line).
kEnableNaCl                    = "enable-nacl";
 
// Enable Native Web Worker support.
kEnableNativeWebWorkers        = "enable-native-web-workers";
 
// Enable speculative TCP/IP preconnection.
kEnablePreconnect              = "enable-preconnect";
 
// Enable caching of pre-parsed JS script data.  See http://crbug.com/32407.
kEnablePreparsedJsCaching      = "enable-preparsed-js-caching";
 
// Enable print preview (work in progress).
kEnablePrintPreview            = "enable-print-preview";
 
// Enables StatsTable, logging statistics to a global named shared memory table.
kEnableStatsTable              = "enable-stats-table";
 
// Enable syncing browser data to a Google Account.
kEnableSync                    = "enable-sync";
 
// Enable syncing browser autofill.
kEnableSyncAutofill            = "enable-sync-autofill";
 
// Enable syncing browser bookmarks.
kEnableSyncBookmarks           = "enable-sync-bookmarks";
 
// Enable syncing browser extensions.
kEnableSyncExtensions          = "enable-sync-extensions";
 
// Enable syncing browser passwords.
kEnableSyncPasswords           = "enable-sync-passwords";
 
// Enable syncing browser preferences.
kEnableSyncPreferences         = "enable-sync-preferences";
 
// Enable syncing browser themes.
kEnableSyncThemes              = "enable-sync-themes";
 
// Enable syncing browser typed urls.
kEnableSyncTypedUrls           = "enable-sync-typed-urls";
 
// Enable tabbed options, ie: dom-ui version of options window.
kEnableTabbedOptions           = "enable-tabbed-options";
 
// Whether or not the touch events API is exposed.
kEnableTouch                   = "enable-touch";
 
// Enables the option to show tabs as a vertical stack down the side of the
// browser window.
kEnableVerticalTabs            = "enable-vertical-tabs";
 
// Enables support for fullscreen video. Current implementation is
// incomplete and this flag is used for development and testing.
kEnableVideoFullscreen         = "enable-video-fullscreen";
 
// Enables video layering where video is rendered as a separate layer outside
// of the backing store.
kEnableVideoLayering           = "enable-video-layering";
 
// Enables video logging where video elements log playback performance data to
// the debug log.
kEnableVideoLogging            = "enable-video-logging";
 
// Spawn threads to watch for excessive delays in specified message loops.
// User should set breakpoints on Alarm() to examine problematic thread.
// Usage:   -enable-watchdog=[ui][io]
// Order of the listed sub-arguments does not matter.
kEnableWatchdog                = "enable-watchdog";
 
// Disable WebKit's XSSAuditor.  The XSSAuditor mitigates reflective XSS.
kEnableXSSAuditor              = "enable-xss-auditor";
 
// Enables the experimental Negotiate authentication protocol.
kExperimentalEnableNegotiateAuth =
    "experimental-enable-negotiate-auth";
 
// Enables experimental features for Spellchecker. Right now, the first
// experimental feature is auto spell correct, which corrects words which are
// misppelled by typing the word with two consecutive letters swapped. The
// features that will be added next are:
// 1 - Allow multiple spellcheckers to work simultaneously.
// 2 - Allow automatic detection of spell check language.
// TODO(sidchat): Implement the above fetaures to work under this flag.
kExperimentalSpellcheckerFeatures =
    "experimental-spellchecker-features";
 
// Explicitly allow additional ports using a comma separated list of port
// numbers.
kExplicitlyAllowedPorts        = "explicitly-allowed-ports";
 
// Causes the process to run as an extension subprocess.
kExtensionProcess              = "extension";
 
// Frequency in seconds for Extensions auto-update.
kExtensionsUpdateFrequency     = "extensions-update-frequency";
 
// The file descriptor limit is set to the value of this switch, subject to the
// OS hard limits. Useful for testing that file descriptor exhaustion is handled
// gracefully.
kFileDescriptorLimit           = "file-descriptor-limit";
 
// Display the First Run experience when the browser is started, regardless of
// whether or not it's actually the first run.
kFirstRun                      = "first-run";
 
// Some field tests may rendomized in the browser, and the randomly selected
// outcome needs to be propogated to the renderer.  For instance, this is used
// to modify histograms recorded in the renderer, or to get the renderer to
// also set of its state (initialize, or not initialize components) to match the
// experiment(s).
// The argument is a string-ized list of experiment names, and the associated
// value that was randomly selected.  In the recent implementetaion, the
// persistent representation generated by field_trial.cc and later decoded, is a
// list of name and value pairs, separated by slashes. See field trial.cc for
// current details.
kForceFieldTestNameAndValue    = "force-fieldtest";
 
// Extra command line options for launching the GPU process (normally used
// for debugging). Use like renderer-cmd-prefix.
kGpuLauncher                   = "gpu-launcher";
 
// Makes this process a GPU sub-process.
kGpuProcess                    = "gpu-process";
 
// Causes the GPU process to display a dialog on launch.
kGpuStartupDialog              = "gpu-startup-dialog";
 
// These flags show the man page on Linux. They are equivalent to each
// other.
kHelp                          = "help";
kHelpShort                     = "h";
 
// Make Windows happy by allowing it to show "Enable access to this program"
// checkbox in Add/Remove Programs->Set Program Access and Defaults. This
// only shows an error box because the only way to hide Chrome is by
// uninstalling it.
kHideIcons                     = "hide-icons";
 
// The value of this switch specifies which page will be displayed
// in newly-opened tabs.  We need this for testing purposes so
// that the UI tests don't depend on what comes up for http://google.com.
kHomePage                      = "homepage";
 
// Comma separated list of rules that control how hostnames are mapped.
//
// For example:
//    "MAP * 127.0.0.1" --> Forces all hostnames to be mapped to 127.0.0.1
//    "MAP *.google.com proxy" --> Forces all google.com subdomains to be
//                                 resolved to "proxy".
//    "MAP test.com [::1]:77 --> Forces "test.com" to resolve to IPv6 loopback.
//                               Will also force the port of the resulting
//                               socket address to be 77.
//    "MAP * baz, EXCLUDE www.google.com" --> Remaps everything to "baz",
//                                            except for "www.google.com".
//
// These mappings apply to the endpoint host in a URLRequest (the TCP connect
// and host resolver in a direct connection, and the CONNECT in an http proxy
// connection, and the endpoint host in a SOCKS proxy connection).
kHostRules                     = "host-rules";
 
// These mappins only apply to the host resolver.
kHostResolverRules             = "host-resolver-rules";
 
// Perform importing from another browser. The value associated with this
// setting encodes the target browser and what items to import.
kImport                        = "import";
 
// Perform bookmark importing from an HTML file. The value associated with this
// setting encodes the file path. It may be used jointly with kImport.
kImportFromFile                = "import-from-file";
 
// Runs plugins inside the renderer process
kInProcessPlugins              = "in-process-plugins";
 
// Runs WebGL inside the renderer process.
kInProcessWebGL                = "in-process-webgl";
 
// Causes the browser to launch directly in incognito mode.
kIncognito                     = "incognito";
 
// Back up the profile.
kInstallerTestBackup           = "backup";
 
// Control the build under test.
kInstallerTestBuild            = "build";
 
// Uninstall before running the tests.
kInstallerTestClean            = "clean";
 
// Force the installer tests to run, regardless of the current platform.
kInstallerTestForce            = "force";
 
// Runs the Native Client inside the renderer process.
kInternalNaCl                  = "internal-nacl";
 
// Runs a trusted Pepper plugin inside the renderer process.
kInternalPepper                = "internal-pepper";
 
// The following flags allow users who can reproduce crbug/35198
// to enable extra logging and behaviors.  They will be removed once
// the issue is fixed.
kIssue35198CrxDirBrowser       = "issue35198-crxdir-browser";
kIssue35198ExtraLogging        = "issue35198-logging";
kIssue35198Permission          = "issue35198-permission";
 
// Specifies the flags passed to JS engine
kJavaScriptFlags               = "js-flags";
 
// Load an extension from the specified directory.
kLoadExtension                 = "load-extension";
 
// Load an NPAPI plugin from the specified path.
kLoadPlugin                    = "load-plugin";
 
// Load NPAPI plugins from the specified directory.
kExtraPluginDir                = "extra-plugin-dir";
 
// Will filter log messages to show only the messages that are prefixed
// with the specified value. See also kEnableLogging and kLoggingLevel.
kLogFilterPrefix               = "log-filter-prefix";
 
// Make plugin processes log their sent and received messages to LOG(INFO).
kLogPluginMessages             = "log-plugin-messages";
 
// Sets the minimum log level. Valid values are from 0 to 3:
// INFO = 0, WARNING = 1, LOG_ERROR = 2, LOG_FATAL = 3.
kLoggingLevel                  = "log-level";
 
// Make Chrome default browser
kMakeDefaultBrowser            = "make-default-browser";
 
// Forces the maximum disk space to be used by the media cache, in bytes.
kMediaCacheSize                = "media-cache-size";
 
// Enable dynamic loading of the Memory Profiler DLL, which will trace
// all memory allocations during the run.
kMemoryProfiling               = "memory-profile";
 
// Enable histograming of tasks served by MessageLoop. See about:histograms/Loop
// for results, which show frequency of messages on each thread, including APC
// count, object signalling count, etc.
kMessageLoopHistogrammer       = "message-loop-histogrammer";
 
// Enables the recording of metrics reports but disables reporting.  In
// contrast to kDisableMetrics, this executes all the code that a normal client
// would use for reporting, except the report is dropped rather than sent to
// the server. This is useful for finding issues in the metrics code during UI
// and performance tests.
kMetricsRecordingOnly          = "metrics-recording-only";
 
// Causes the process to run as a NativeClient broker
// (used for launching NaCl loader processes on 64-bit Windows).
kNaClBrokerProcess             = "nacl-broker";
 
// Causes the process to run as a NativeClient loader.
kNaClLoaderProcess             = "nacl-loader";
 
// Causes the Native Client process to display a dialog on launch.
kNaClStartupDialog             = "nacl-startup-dialog";
 
// Uses the new unified app menu instead of the old "page/app" split menus.
kNewWrenchMenu                 = "new-wrench-menu";
 
// Disables the default browser check. Useful for UI/browser tests where we
// want to avoid having the default browser info-bar displayed.
kNoDefaultBrowserCheck         = "no-default-browser-check";
 
// Don't record/playback events when using record & playback.
kNoEvents                      = "no-events";
 
// Bypass the First Run experience when the browser is started, regardless of
// whether or not it's actually the first run. Overrides kFirstRun in case
// you're for some reason tempted to pass them both.
kNoFirstRun                    = "no-first-run";
 
// Support a separate switch that enables the v8 playback extension.
// The extension causes javascript calls to Date.now() and Math.random()
// to return consistent values, such that subsequent loads of the same
// page will result in consistent js-generated data and XHR requests.
// Pages may still be able to generate inconsistent data from plugins.
kNoJsRandomness                = "no-js-randomness";
 
// Don't send HTTP-Referer headers.
kNoReferrers                   = "no-referrers";
 
// Don't use a proxy server, always make direct connections. Overrides any
// other proxy server flags that are passed.
kNoProxyServer                 = "no-proxy-server";
 
// Runs the renderer outside the sandbox.
kNoSandbox                     = "no-sandbox";
 
// Launch URL in new browser window.
kOpenInNewWindow               = "new-window";
 
// Package an extension to a .crx installable file from a given directory.
kPackExtension                 = "pack-extension";
 
// Optional PEM private key is to use in signing packaged .crx.
kPackExtensionKey              = "pack-extension-key";
 
// Specifies the path to the user data folder for the parent profile.
kParentProfile                 = "parent-profile";
 
// Read previously recorded data from the cache. Only cached data is read.
// See kRecordMode.
kPlaybackMode                  = "playback-mode";
 
// Specifies the plugin data directory, which is where plugins (Gears
// specifically) will store its state.
kPluginDataDir                 = "plugin-data-dir";
 
// Specifies a command that should be used to launch the plugin process.  Useful
// for running the plugin process through purify or quantify.  Ex:
//   --plugin-launcher="path\to\purify /Run=yes"
kPluginLauncher                = "plugin-launcher";
 
// Tells the plugin process the path of the plugin to load
kPluginPath                    = "plugin-path";
 
// Causes the process to run as a plugin subprocess.
kPluginProcess                 = "plugin";
 
// Causes the plugin process to display a dialog on launch.
kPluginStartupDialog           = "plugin-startup-dialog";
 
// Prints the pages on the screen.
kPrint = "print";
 
// Runs a single process for each site (i.e., group of pages from the same
// registered domain) the user visits.  We default to using a renderer process
// for each site instance (i.e., group of pages from the same registered
// domain with script connections to each other).
kProcessPerSite                = "process-per-site";
 
// Runs each set of script-connected tabs (i.e., a BrowsingInstance) in its own
// renderer process.  We default to using a renderer process for each
// site instance (i.e., group of pages from the same registered domain with
// script connections to each other).
kProcessPerTab                 = "process-per-tab";
 
// Output the product version information and quit. Used as an internal api to
// detect the installed version of Chrome on Linux.
kProductVersion                = "product-version";
 
// Causes the process to run as a profile import subprocess.
kProfileImportProcess          = "profile-import";
 
// Force proxy auto-detection.
kProxyAutoDetect               = "proxy-auto-detect";
 
// Specify a list of hosts for whom we bypass proxy settings and use direct
// connections. Ignored if --proxy-auto-detect or --no-proxy-server are
// also specified.
// This is a comma separated list of bypass rules. See:
// "net/proxy/proxy_bypass_rules.h" for the format of these rules.
kProxyBypassList               = "proxy-bypass-list";
 
// Use the pac script at the given URL
kProxyPacUrl                   = "proxy-pac-url";
 
// Use a specified proxy server, overrides system settings. This switch only
// affects HTTP and HTTPS requests.
kProxyServer                   = "proxy-server";
 
// Adds a "Purge memory" button to the Task Manager, which tries to dump as
// much memory as possible.  This is mostly useful for testing how well the
// MemoryPurger functionality works.
//
// NOTE: This is only implemented for Views.
kPurgeMemoryButton             = "purge-memory-button";
 
// Chrome supports a playback and record mode.  Record mode saves *everything*
// to the cache.  Playback mode reads data exclusively from the cache.  This
// allows us to record a session into the cache and then replay it at will.
// See also kPlaybackMode.
kRecordMode                    = "record-mode";
 
// Register pepper plugins that should be loaded into the renderer.
kRegisterPepperPlugins         = "register-pepper-plugins";
 
// Enable remote debug / automation shell on the specified port.
kRemoteShellPort               = "remote-shell-port";
 
// Causes the renderer process to throw an assertion on launch.
kRendererAssertTest            = "renderer-assert-test";
 
// On POSIX only: the contents of this flag are prepended to the renderer
// command line. Useful values might be "valgrind" or "xterm -e gdb --args".
kRendererCmdPrefix             = "renderer-cmd-prefix";
 
// Causes the renderer process to crash on launch.
kRendererCrashTest             = "renderer-crash-test";
 
// Causes the process to run as renderer instead of as browser.
kRendererProcess               = "renderer";
 
// Causes the renderer process to display a dialog on launch.
kRendererStartupDialog         = "renderer-startup-dialog";
 
// Causes the URLs of BackgroundContents to be remembered and re-launched when
// the browser restarts.
kRestoreBackgroundContents     = "restore-background-contents";
 
// Indicates the last session should be restored on startup. This overrides
// the preferences value and is primarily intended for testing. The value of
// this switch is the number of tabs to wait until loaded before
// 'load completed' is sent to the ui_test.
kRestoreLastSession            = "restore-last-session";
 
// Runs the plugin processes inside the sandbox.
kSafePlugins                   = "safe-plugins";
 
// URL prefix used by safebrowsing to fetch hash, download data and
// report malware.
kSbInfoURLPrefix = "safebrowsing-info-url-prefix";
// URL prefix used by safebrowsing to get MAC key.
kSbMacKeyURLPrefix = "safebrowsing-mackey-url-prefix";
// If present, safebrowsing only performs update when
// SafeBrowsingProtocolManager::ForceScheduleNextUpdate() is explicitly called.
// This is used for testing only.
kSbDisableAutoUpdate = "safebrowsing-disable-auto-update";
 
// Enable support for SDCH filtering (dictionary based expansion of content).
// Optional argument is *the* only domain name that will have SDCH suppport.
// Default is  "-enable-sdch" to advertise SDCH on all domains.
// Sample usage with argument: "-enable-sdch=.google.com"
// SDCH is currently only supported server-side for searches on google.com.
kSdchFilter                    = "enable-sdch";
 
// Enables the showing of an info-bar instructing user they can search directly
// from the omnibox.
kSearchInOmniboxHint           = "search-in-omnibox-hint";
 
// Causes the process to run as a service process.
kServiceProcess                = "service";
 
// The LSID of the account to use for the service process.
kServiceAccountLsid            = "service-account-lsid";
 
// See kHideIcons.
kShowIcons                     = "show-icons";
 
// Renders a border around composited Render Layers to help debug and study
// layer compositing.
kShowCompositedLayerBorders    = "show-composited-layer-borders";
 
// Visibly render a border around paint rects in the web page to help debug
// and study painting behavior.
kShowPaintRects                = "show-paint-rects";
 
// Change the DCHECKS to dump memory and continue instead of displaying error
// dialog. This is valid only in Release mode when --enable-dcheck is
// specified.
kSilentDumpOnDCHECK            = "silent-dump-on-dcheck";
 
// Replaces the buffered data source for  and  with a simplified
// resource loader that downloads the entire resource into memory.
//
// TODO(scherkus): remove --simple-data-source when our media resource loading
// is cleaned up and playback testing completed.
kSimpleDataSource              = "simple-data-source";
 
// Runs the renderer and plugins in the same process as the browser
kSingleProcess                 = "single-process";
 
// Start the browser maximized, regardless of any previous settings.
kStartMaximized                = "start-maximized";
 
// Control Sync XMPP client settings.
kSyncAllowPlain                = "allow-plain";
 
// Control Sync XMPP client settings.
kSyncDisableTls                = "disable-tls";
 
// Email used for sync.
kSyncEmail                     = "email";
 
// Use the SyncerThread implementation that matches up with the old pthread
// impl semantics, but using Chrome synchronization primitives.  The only
// difference between this and the default is that we now have no timeout on
// Stop().  Should only use if you experience problems with the default.
kSyncerThreadTimedStop         = "syncer-thread-timed-stop";
 
// Override the default notification method for sync.
kSyncNotificationMethod        = "sync-notification-method";
 
// Password used for sync.
kSyncPassword                  = "password";
 
// Port used for sync.
kSyncPort                      = "port";
 
// Server used for sync.
kSyncServer                    = "server";
 
// Override the default server used for profile sync.
kSyncServiceURL                = "sync-url";
 
// Control Sync XMPP client settings.
kSyncUseSslTcp                 = "use-ssl-tcp";
 
// Control Sync XMPP client settings.
kSyncUseCacheInvalidation      = "use-cache-invalidation";
 
// Pass the name of the current running automated test to Chrome.
kTestName                      = "test-name";
 
// Runs the security test for the sandbox.
kTestSandbox                   = "test-sandbox";
 
// Pass the type of the current test harness ("browser" or "ui")
kTestType                      = "test-type";
 
// The value of this switch tells the app to listen for and broadcast
// testing-related messages on IPC channel with the given ID.
kTestingChannelID              = "testing-channel";
 
// Enables using TopSites instead of ThumbnailDatabase (and
// ThumbnailStore) for getting thumbnails for the new tab page.
kTopSites                      = "top-sites";
 
// Excludes these plugins from the plugin sandbox.
// This is a comma-separated list of plugin library names.
kTrustedPlugins                = "trusted-plugins";
 
// Experimental. Shows a dialog asking the user to try chrome. This flag
// is to be used only by the upgrade process.
kTryChromeAgain                = "try-chrome-again";
 
// Runs un-installation steps that were done by chrome first-run.
kUninstall                     = "uninstall";
 
// Use Spdy for the transport protocol instead of HTTP.
// This is a temporary testing flag.
kUseSpdy                       = "use-spdy";
 
// These two flags are used to force http and https requests to fixed ports.
kFixedHttpPort                 = "testing-fixed-http-port";
kFixedHttpsPort                = "testing-fixed-https-port";
 
// Ignore certificate related errors.
kIgnoreCertificateErrors       = "ignore-certificate-errors";
 
// Set the maximum SPDY sessions per domain.
kMaxSpdySessionsPerDomain      = "max-spdy-sessions-per-domain";
 
// Use the low fragmentation heap for the CRT.
kUseLowFragHeapCrt             = "use-lf-heap";
 
// A string used to override the default user agent with a custom one.
kUserAgent                     = "user-agent";
 
// Specifies the user data directory, which is where the browser will look
// for all of its state.
kUserDataDir                   = "user-data-dir";
 
// directory to locate user scripts in as an over-ride of the default
kUserScriptsDir                = "user-scripts-dir";
 
// On POSIX only: the contents of this flag are prepended to the utility
// process command line. Useful values might be "valgrind" or "xterm -e gdb
// --args".
kUtilityCmdPrefix              = "utility-cmd-prefix";
 
// Causes the process to run as a utility subprocess.
kUtilityProcess                = "utility";
 
// The utility process is sandboxed, with access to one directory. This flag
// specifies the directory that can be accessed.
kUtilityProcessAllowedDir      = "utility-allowed-dir";
 
// Print version information and quit.
kVersion                       = "version";
 
// Will add kWaitForDebugger to every child processes. If a value is passed, it
// will be used as a filter to determine if the child process should have the
// kWaitForDebugger flag passed on or not.
kWaitForDebuggerChildren       = "wait-for-debugger-children";
 
// Causes the worker process allocation to use as many processes as cores.
kWebWorkerProcessPerCore       = "web-worker-process-per-core";
 
// Causes workers to run together in one process, depending on their domains.
// Note this is duplicated in webworkerclient_impl.cc
kWebWorkerShareProcesses       = "web-worker-share-processes";
 
// Use WinHTTP to fetch and evaluate PAC scripts. Otherwise the default is
// to use Chromium's network stack to fetch, and V8 to evaluate.
kWinHttpProxyResolver          = "winhttp-proxy-resolver";
 
// Causes the process to run as a worker subprocess.
kWorkerProcess                 = "worker";
 
// The prefix used when starting the zygote process. (i.e. 'gdb --args')
kZygoteCmdPrefix               = "zygote-cmd-prefix";
 
// Causes the process to run as a renderer zygote.
kZygoteProcess                 = "zygote";

// Causes the renderer process to throw an assertion on launch.
kRendererCheckFalseTest        = "renderer-check-false-test";

// Enable the redirection of viewable document requests to the Google
// Document Viewer.
kEnableGView                   = "enable-gview";
 
// Should we show the image based login?
kEnableLoginImages             = "enable-login-images";
 
// Enable Chrome-as-a-login-manager behavior.
kLoginManager                  = "login-manager";
// Allows to override the first login screen. The value should be the name
// of the first login screen to show (see
// chrome/browser/chromeos/login/login_wizard_view.cc for actual names).
// Ignored if kLoginManager is not specified.
// TODO(avayvod): Remove when the switch is no longer needed for testing.
kLoginScreen                   = "login-screen";
// Allows control over the initial login screen size. Pass width,height.
kLoginScreenSize               = "login-screen-size";
 
// Attempts to load libcros and validate it, then exits. A nonzero return code
// means the library could not be loaded correctly.
kTestLoadLibcros               = "test-load-libcros";
 
// TODO(davemoore) Delete this once chromeos has started using
// login-profile as its arg.
kProfile                       = "profile";
 
// Specifies the profile to use once a chromeos user is logged in.
kLoginProfile                  = "login-profile";
 
// Specifies the user which is already logged in.
kLoginUser                     = "login-user";
 
// Use the frame layout used in chromeos.
kChromeosFrame                 = "chromeos-frame";
 
// Set logging output to the given file.
kChromeosLogToFile             = "logtofile";
 
// Specify startup customization manifest.
// TODO(denisromanov): delete this when not needed for testing.
kStartupManifest               = "startup-manifest";
 
// Specify services customization manifest.
// TODO(denisromanov): delete this when not needed for testing.
kServicesManifest              = "services-manifest";

// Specify the amount the trackpad should scroll by.
kScrollPixels                  = "scroll-pixels";

// Use the system SSL library (Secure Transport on Mac, SChannel on Windows)
// instead of NSS for SSL.
kUseSystemSSL                  = "use-system-ssl";

// Bypass the error dialog when the profile lock couldn't be attained.
// A flag, generated internally by Chrome for renderer and other helper process
// command lines on Linux and Mac.  It tells the helper process to enable crash
// dumping and reporting, because helpers cannot access the profile or other
// files needed to make this decision.
// If passed to the browser, it'll be passed on to all the helper processes
// as well, thereby force-enabling the crash reporter.
kEnableCrashReporter           = "enable-crash-reporter";
 
// This switch is used during automated testing.
kNoProcessSingletonDialog      = "no-process-singleton-dialog";

// Specifies which password store to use (detect, default, gnome, kwallet).
kPasswordStore                 = "password-store";
// Enable Kiosk mode.
kKioskMode                     = "kiosk";

// Cause the OS X sandbox write to syslog every time an access to a resource
// is denied by the sandbox.
kEnableSandboxLogging          = "enable-sandbox-logging";
 
// Temporary flag to prevent Flash from negotiating the Core Animation drawing
// model. This will be removed once the last issues have been resolved.
kDisableFlashCoreAnimation     = "disable-flash-core-animation";

#ifndef NDEBUG
// Debug only switch to specify which gears plugin dll to load.
kGearsPluginPathOverride       = "gears-plugin-path";
 
// Makes sure any sync login attempt will fail with an error.  (Only
// used for testing.)
kInvalidateSyncLogin           = "invalidate-sync-login";
 
// Makes sure any sync xmpp login attempt will fail with an error.  (Only
// used for testing.)
kInvalidateSyncXmppLogin       = "invalidate-sync-xmpp-login";
 
// Debug only switch to specify which websocket live experiment host to be used.
// If host is specified, it also makes initial delay shorter (5 min to 5 sec)
// to make it faster to test websocket live experiment code.
kWebSocketLiveExperimentHost   = "websocket-live-experiment-host";
#endif
 
// USE_SECCOMP_SANDBOX controls whether the seccomp sandbox is opt-in or -out.
// TODO(evan): unify all of these once we turn the seccomp sandbox always
// on.  Also remove the #include of command_line.h above.
#if defined(USE_SECCOMP_SANDBOX)
// Disable the seccomp sandbox (Linux only)
kDisableSeccompSandbox         = "disable-seccomp-sandbox";
#else
// Enable the seccomp sandbox (Linux only)
kEnableSeccompSandbox          = "enable-seccomp-sandbox";
#endif