tree: b1b0638e08ffca672c4d533b13b2096246a6f433 [path history] [tgz]
  1. accelerators/
  2. accessibility/
  3. animation/
  4. app_list/
  5. app_menu/
  6. ash_strings_grd/
  7. assistant/
  8. autoclick/
  9. components/
  10. content/
  11. dbus/
  12. detachable_base/
  13. display/
  14. drag_drop/
  15. events/
  16. first_run/
  17. frame/
  18. high_contrast/
  19. highlighter/
  20. host/
  21. ime/
  22. keyboard/
  23. laser/
  24. lock_screen_action/
  25. login/
  26. magnifier/
  27. message_center/
  28. metrics/
  29. multi_device_setup/
  30. perftests/
  31. policy/
  32. public/
  33. resources/
  34. rotator/
  35. session/
  36. shelf/
  37. shell/
  38. sticky_keys/
  39. strings/
  40. system/
  41. test/
  42. tooltips/
  43. touch/
  44. tray_action/
  45. utility/
  46. voice_interaction/
  47. wallpaper/
  48. wayland/
  49. wm/
  50. ws/
  52. ash_export.h
  54. ash_service.h
  56. ash_strings.grd
  57. ash_unittests_manifest.json
  60. cancel_mode.h
  62. cast_config_controller.h
  64. client_image_registry.h
  67. debug.h
  68. DEPS
  71. disconnected_app_handler.h
  74. focus_cycler.h
  76. login_status.h
  78. manifest.json
  80. media_controller.h
  82. mojo_interface_factory.h
  84. mojo_test_interface_factory.h
  86. multi_profile_uma.h
  89. network_connect_delegate_mus.h
  91. new_window_controller.h
  93. note_taking_controller.h
  94. OWNERS
  96. pointer_watcher_adapter.h
  101. root_window_controller.h
  104. root_window_settings.h
  106. scoped_root_window_for_new_windows.h
  108. screen_util.h
  110. screenshot_delegate.h
  112. shell.h
  113. shell_delegate.h
  115. shell_delegate_mash.h
  117. shell_init_params.h
  118. shell_observer.h
  120. shell_state.h
  123. shell_test_api.h
  126. shutdown_controller.h
  128. shutdown_reason.h
  130. test_media_client.h
  132. test_screenshot_delegate.h
  134. test_shell_delegate.h
  136. window_factory.h
  137. window_user_data.h


Ash is the “Aura Shell”, the window manager and system UI for Chrome OS. Ash uses the views UI toolkit (e.g. views::View, views::Widget, etc.) backed by the aura native widget and layer implementations.

Ash sits below chrome in the dependency graph (i.e. it cannot depend on code in //chrome). It has a few dependencies on //content, but these are isolated in their own module in //ash/content. This allows targets like ash_unittests to build more quickly.


Most tests should be added to the ash_unittests target. Tests that rely on //content should be added to ash_content_unittests, but these should be rare.

Tests can bring up most of the ash UI and simulate a login session by deriving from AshTestBase. This is often needed to test code that depends on ash::Shell and the controllers it owns.

Test support code (TestFooDelegate, FooControllerTestApi, etc.) lives in the same directory as the class under test (e.g. //ash/foo rather than //ash/test). Test code uses namespace ash; there is no special “test” namespace.


Ash is transitioning to run as a mojo service in its own process. This change means that code in chrome cannot call into ash directly, but must use the mojo interfaces in //ash/public/interfaces.

Out-of-process Ash is referred to as “mash” (mojo ash). In-process ash is referred to as “classic ash”. Ash can run in either mode depending on the --enable-features=Mash command line flag.

In the few cases where chrome code is allowed to call into ash (e.g. code that will only ever run in classic ash) the #include lines have “// mash-ok” appended. This makes it easier to use grep to determine which parts of chrome have not yet been adapted to mash.

Ash used to support a “mus” mode that ran the mojo window service from //services/ui on a background thread in the browser process. This configuration was deprecated in April 2018.


Before launching Mash we plan to launch SingleProcessMash. SingleProcessMash is similar to “classic ash” in that ash and the browser still live in the same process and on the same thread, but all non-ash UI code (such as browser windows) will use the WindowService over mojo. This results in exercising much of the same code as in mash, but everything is still in the process.

In SingleProcessMash mode there are two aura::Envs. Ash (Shell) creates one and the browser creates one. In order to ensure the right one is used do the following:

. When creating a Widget set the parent and/or context. If you don't need a specific parent (container), more often than not using a context of Shell::GetRootWindowForNewWindows() is what you want. . If you are creating aura::Windows directly, use the ash::window_factory. . If you need access to aura::Env, get it from Shell. Shell always returns the right one, regardless of mode.

See for more details.

Mash Tests

ash_unittests has some tests specific to Mash, but in general Ash code should not need to do anything special for Mash. AshTestBase offers functions that simulate a remote client (such as the browser) creating a window.

To enable browser_tests to run in Mash use “--enable-features=Mash”. As Mash is still a work in progress not all tests pass. A filter file is used on the bots to exclude failing tests (testing/buildbot/filters/mash.browser_tests.filter).

To simulate what the bots run (e.g. to check if you broke an existing test that works under mash) you can run:

browser_tests --enable-features=Mash --test-launcher-filter-file=testing/buildbot/filters/mash.browser_tests.filter

Any new feature you add (and its tests) should work under mash. If your test cannot pass under mash due to some dependency being broken you may add the test to the filter file. Make sure there is a bug for the underlying issue and cite it in the filter file.


Ash supports both per-user prefs and device-wide prefs. These are called “profile prefs” and “local state” to match the naming conventions in chrome. Ash also supports “signin screen” prefs, bound to a special profile that allows users to toggle features like spoken feedback at the login screen.

Local state prefs are loaded asynchronously during startup. User prefs are loaded asynchronously after login, and after adding a multiprofile user. Code that wants to observe prefs must wait until they are loaded. See ShellObserver::OnLocalStatePrefServiceInitialized() and SessionObserver::OnActiveUserPrefServiceChanged(). All PrefService objects exist for the lifetime of the login session, including the signin prefs.

Pref names are in //ash/public/cpp so that code in chrome can also use the names. Prefs are registered in the classes that use them because those classes have the best knowledge of default values.

All PrefService instances in ash are backed by the mojo preferences service. This means an update to a pref is asynchronous between code in ash and code in chrome. For example, if code in chrome changes a pref value then immediately calls a C++ function in ash, that ash function may not see the new value yet. (This pattern only happens in the classic ash configuration; code in chrome cannot call directly into the ash process in the mash config.)

Prefs are either “owned” by ash or by chrome browser. New prefs used by ash should be owned by ash. See NightLightController and LogoutButtonTray for examples of ash-owned prefs. See //services/preferences/ for details of pref ownership and “foreign” prefs.

Historical notes

Ash shipped on Windows for a couple years to support Windows 8 Metro mode. Windows support was removed in 2016.