chromeos: turn on simplified display management for mash

ash/shell.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/shell.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 310 matching lines @@
               switches::kUseIMEService));
 }
 
 // static
 void Shell::RegisterPrefs(PrefRegistrySimple* registry) {
   NightLightController::RegisterPrefs(registry);
 }
 
 // static
 bool Shell::ShouldEnableSimplifiedDisplayManagement() {
-  return GetAshConfig() != Config::MASH;
+  return ShouldEnableSimplifiedDisplayManagement(GetAshConfig());
+}
+
+bool Shell::ShouldEnableSimplifiedDisplayManagement(Config config) {
+  return true;
 }
 
 views::NonClientFrameView* Shell::CreateDefaultNonClientFrameView(
     views::Widget* widget) {
   // Use translucent-style window frames for dialogs.
   return new CustomFrameViewAsh(widget);
 }
 
 void Shell::SetDisplayWorkAreaInsets(Window* contains,
                                      const gfx::Insets& insets) {
@@ skipping 23 matching lines @@
     RootWindowControllerList controllers = GetAllRootWindowControllers();
     for (RootWindowControllerList::iterator iter = controllers.begin();
          iter != controllers.end(); ++iter) {
       (*iter)->DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
     }
   }
   keyboard::KeyboardController::ResetInstance(nullptr);
 }
 
 bool Shell::ShouldSaveDisplaySettings() {
+  // This function is only called from Chrome, hence the DCHECK for not-MASH.
   DCHECK(GetAshConfig() != Config::MASH);
   return !(
       screen_orientation_controller_->ignore_display_configuration_updates() ||
       resolution_notification_controller_->DoesNotificationTimeout());
 }
 
 ShelfModel* Shell::shelf_model() {
   return shelf_controller_->model();
 }
 
@@ skipping 200 matching lines @@
       display_configurator_(new display::DisplayConfigurator()),
       native_cursor_manager_(nullptr),
       simulate_modal_window_open_for_testing_(false),
       is_touch_hud_projection_enabled_(false) {
   // TODO(sky): better refactor cash/mash dependencies. Perhaps put all cash
   // state on ShellPortClassic. http://crbug.com/671246.
 
   gpu_support_.reset(shell_delegate_->CreateGPUSupport());
 
   // Don't use Shell::GetAshConfig() as |instance_| has not yet been set.
-  if (shell_port_->GetAshConfig() != Config::MASH) {
+  if (ShouldEnableSimplifiedDisplayManagement(shell_port_->GetAshConfig())) {
     display_manager_.reset(ScreenAsh::CreateDisplayManager());
     window_tree_host_manager_.reset(new WindowTreeHostManager);
     user_metrics_recorder_.reset(new UserMetricsRecorder);
   }
 
   PowerStatus::Initialize();
 
   session_controller_->AddObserver(this);
 }
 
@@ skipping 22 matching lines @@
   RemovePreTargetHandler(speech_feedback_handler_.get());
   speech_feedback_handler_.reset();
 
   RemovePreTargetHandler(overlay_filter_.get());
   overlay_filter_.reset();
 
   RemovePreTargetHandler(accelerator_filter_.get());
   RemovePreTargetHandler(event_transformation_handler_.get());
   RemovePreTargetHandler(toplevel_window_event_handler_.get());
   RemovePostTargetHandler(toplevel_window_event_handler_.get());
-  if (config != Config::MASH) {
+  if (ShouldEnableSimplifiedDisplayManagement()) {
     RemovePreTargetHandler(system_gesture_filter_.get());
     RemovePreTargetHandler(mouse_cursor_filter_.get());
   }
   RemovePreTargetHandler(modality_filter_.get());
 
   // TooltipController is deleted with the Shell so removing its references.
   RemovePreTargetHandler(tooltip_controller_.get());
 
   screen_orientation_controller_.reset();
   screen_layout_observer_.reset();
@@ skipping 199 matching lines @@
   window_positioner_ = base::MakeUnique<WindowPositioner>();
 
   if (config == Config::CLASSIC) {
     // TODO: needs to work in mus. http://crbug.com/705592.
     native_cursor_manager_ = new AshNativeCursorManager;
     cursor_manager_.reset(
         new CursorManager(base::WrapUnique(native_cursor_manager_)));
   }
 
   shell_delegate_->PreInit();
-  // TODO(sky): remove MASH from here.
-  bool display_initialized =
-      (config == Config::MASH || display_manager_->InitFromCommandLine());
-  if (config == Config::MUS && !display_initialized) {
+  bool display_initialized = (!ShouldEnableSimplifiedDisplayManagement() ||
+                              display_manager_->InitFromCommandLine());
+  if (!display_initialized && config != Config::CLASSIC &&
+      ShouldEnableSimplifiedDisplayManagement()) {
     // Run display configuration off device in mus mode.
     display_manager_->set_configure_displays(true);
     display_configurator_->set_configure_display(true);
   }
-  if (config != Config::MASH) {
-    // TODO(sky): should work in mash too.
+  if (ShouldEnableSimplifiedDisplayManagement()) {
     display_configuration_controller_.reset(new DisplayConfigurationController(
         display_manager_.get(), window_tree_host_manager_.get()));
     display_configurator_->Init(shell_port_->CreateNativeDisplayDelegate(),
                                 !gpu_support_->IsPanelFittingDisabled());
   }
 
   // The DBusThreadManager must outlive this Shell. See the DCHECK in ~Shell.
   chromeos::DBusThreadManager* dbus_thread_manager =
       chromeos::DBusThreadManager::Get();
   projecting_observer_.reset(
       new ProjectingObserver(dbus_thread_manager->GetPowerManagerClient()));
   display_configurator_->AddObserver(projecting_observer_.get());
   AddShellObserver(projecting_observer_.get());
 
-  // TODO(sky): once simplified display management is enabled for mash
-  // config == Config::MUS should be config != Config::CLASSIC.
-  if (!display_initialized &&
-      (config == Config::MUS || chromeos::IsRunningAsSystemCompositor())) {
+  if (!display_initialized && ((config != Config::CLASSIC &&
+                                ShouldEnableSimplifiedDisplayManagement()) ||
+                               chromeos::IsRunningAsSystemCompositor())) {
     display_change_observer_ = base::MakeUnique<display::DisplayChangeObserver>(
         display_configurator_.get(), display_manager_.get());
 
     shutdown_observer_ =
         base::MakeUnique<ShutdownObserver>(display_configurator_.get());
 
     // Register |display_change_observer_| first so that the rest of
     // observer gets invoked after the root windows are configured.
     display_configurator_->AddObserver(display_change_observer_.get());
     display_error_observer_.reset(new DisplayErrorObserver());
     display_configurator_->AddObserver(display_error_observer_.get());
     display_configurator_->set_state_controller(display_change_observer_.get());
     display_configurator_->set_mirroring_controller(display_manager_.get());
     display_configurator_->ForceInitialConfigure(
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             chromeos::switches::kFirstExecAfterBoot)
             ? kChromeOsBootColor
             : 0);
     display_initialized = true;
   }
   display_color_manager_.reset(new DisplayColorManager(
       display_configurator_.get(), init_params.blocking_pool));
 
   if (!display_initialized)
     display_manager_->InitDefaultDisplay();
 
-  if (config == Config::CLASSIC) {
+  // TODO(sky): move this to chrome for mash.
+  if (ShouldEnableSimplifiedDisplayManagement())
     display_manager_->RefreshFontParams();
 
+  if (config == Config::CLASSIC) {
     aura::Env::GetInstance()->set_context_factory(init_params.context_factory);
     aura::Env::GetInstance()->set_context_factory_private(
         init_params.context_factory_private);
   }
 
   // The WindowModalityController needs to be at the front of the input event
   // pretarget handler list to ensure that it processes input events when modal
   // windows are active.
   window_modality_controller_.reset(new ::wm::WindowModalityController(this));
 
   env_filter_.reset(new ::wm::CompoundEventFilter);
   AddPreTargetHandler(env_filter_.get());
 
   // FocusController takes ownership of AshFocusRules.
   focus_controller_ =
       base::MakeUnique<::wm::FocusController>(new wm::AshFocusRules());
   focus_controller_->AddObserver(this);
   if (config != Config::CLASSIC) {
     window_tree_client_->focus_synchronizer()->SetSingletonFocusClient(
         focus_controller_.get());
   }
 
   screen_position_controller_.reset(new ScreenPositionController);
 
   shell_port_->CreatePrimaryHost();
   root_window_for_new_windows_ = GetPrimaryRootWindow();
 
-  if (config != Config::MASH) {
+  if (ShouldEnableSimplifiedDisplayManagement()) {
     resolution_notification_controller_.reset(

[msw, 2017/05/26 16:38:50]

optional nit: base::MakeUnique here and below

[sky, 2017/06/05 22:37:40]

I'm holding off on this.

         new ResolutionNotificationController);
   }
 
   if (cursor_manager_) {
     cursor_manager_->SetDisplay(
         display::Screen::GetScreen()->GetPrimaryDisplay());
   }
 
   accelerator_controller_ = shell_port_->CreateAcceleratorController();
   maximize_mode_controller_ = base::MakeUnique<MaximizeModeController>();
@@ skipping 51 matching lines @@
   }
 
   drag_drop_controller_.reset(new DragDropController);
   // |screenshot_controller_| needs to be created (and prepended as a
   // pre-target handler) at this point, because |mouse_cursor_filter_| needs to
   // process mouse events prior to screenshot session.
   // See http://crbug.com/459214
   screenshot_controller_.reset(new ScreenshotController());
   // TODO: evaluate if MouseCursorEventFilter needs to work for mash.
   // http://crbug.com/706474.
-  if (config != Config::MASH) {
+  if (ShouldEnableSimplifiedDisplayManagement()) {
     mouse_cursor_filter_.reset(new MouseCursorEventFilter());
     PrependPreTargetHandler(mouse_cursor_filter_.get());
   }
 
   // Create Controllers that may need root window.
   // TODO(oshima): Move as many controllers before creating
   // RootWindowController as possible.
   visibility_controller_.reset(new AshVisibilityController);
 
   laser_pointer_controller_.reset(new LaserPointerController());
@@ skipping 62 matching lines @@
       cursor_manager_->HideCursor();
     cursor_manager_->SetCursor(ui::CursorType::kPointer);
   }
 
   power_event_observer_.reset(new PowerEventObserver());
   user_activity_notifier_.reset(
       new ui::UserActivityPowerManagerNotifier(user_activity_detector_.get()));
   video_activity_notifier_.reset(
       new VideoActivityNotifier(video_detector_.get()));
   bluetooth_notification_controller_.reset(new BluetoothNotificationController);
-  if (config != Config::MASH) {
+  if (ShouldEnableSimplifiedDisplayManagement()) {
     screen_orientation_controller_.reset(new ScreenOrientationController());
     screen_layout_observer_.reset(new ScreenLayoutObserver());
   }
   sms_observer_.reset(new SmsObserver());
 
   // The compositor thread and main message loop have to be running in
   // order to create mirror window. Run it after the main message loop
   // is started.
-  if (config != Config::MASH)
+  if (ShouldEnableSimplifiedDisplayManagement())
     display_manager_->CreateMirrorWindowAsyncIfAny();
 
   for (auto& observer : shell_observers_)
     observer.OnShellInitialized();
 
   if (config != Config::MASH)
     user_metrics_recorder_->OnShellInitialized();
 }
 
 void Shell::InitKeyboard() {
@@ skipping 151 matching lines @@
 void Shell::OnPrefServiceInitialized(
     std::unique_ptr<::PrefService> pref_service) {
   if (!instance_)
     return;
   // |pref_service_| is null if can't connect to Chrome (as happens when
   // running mash outside of chrome --mash and chrome isn't built).
   pref_service_ = std::move(pref_service);
 }
 
 }  // namespace ash