chromeos: Makes mushrome use simplified display management

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 134 matching lines @@
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/user_activity/user_activity_detector.h"
 #include "ui/chromeos/user_activity_power_manager_notifier.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/display/display.h"
 #include "ui/display/manager/chromeos/display_change_observer.h"
 #include "ui/display/manager/chromeos/display_configurator.h"
 #include "ui/display/manager/display_manager.h"
 #include "ui/display/screen.h"
+#include "ui/display/types/native_display_delegate.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_switches.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/views/corewm/tooltip_aura.h"
 #include "ui/views/corewm/tooltip_controller.h"
 #include "ui/views/focus/focus_manager_factory.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/accelerator_filter.h"
 #include "ui/wm/core/compound_event_filter.h"
 #include "ui/wm/core/focus_controller.h"
 #include "ui/wm/core/shadow_controller.h"
 #include "ui/wm/core/visibility_controller.h"
 #include "ui/wm/core/window_modality_controller.h"
 
-#if defined(USE_X11)
-#include "ui/display/manager/chromeos/x11/native_display_delegate_x11.h"
-#include "ui/gfx/x/x11_types.h"  // nogncheck
-#endif
-
-#if defined(USE_OZONE)
-#include "ui/display/types/native_display_delegate.h"
-#include "ui/ozone/public/ozone_platform.h"
-#endif
-
 namespace ash {
 
 namespace {
 
 using aura::Window;
 using views::Widget;
 
 // A Corewm VisibilityController subclass that calls the Ash animation routine
 // so we can pick up our extended animations. See ash/wm/window_animations.h.
 class AshVisibilityController : public ::wm::VisibilityController {
@@ skipping 370 matching lines @@
       app_list_(base::MakeUnique<app_list::AppList>()),
       link_handler_model_factory_(nullptr),
       tray_bluetooth_helper_(base::MakeUnique<TrayBluetoothHelper>()),
       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) {
-    gpu_support_.reset(shell_delegate_->CreateGPUSupport());
     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 239 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();
-  bool display_initialized = true;
-  if (config == Config::CLASSIC) {
-    // TODO: decide if this needs to be made to work in Config::MUS.
-    // http://crbug.com/705595.
-    display_initialized = display_manager_->InitFromCommandLine();
-
+  // TODO(sky): remove MASH from here.
+  bool display_initialized =
+      (config == Config::MASH || display_manager_->InitFromCommandLine());

[kylechar, 2017/04/26 16:41:44]

display_manager_->InitFromCommandLine() is what makes display manager load it's
own DisplayInfo if --ash-host-window-bounds flag exists. This is the fake
display path that classic ash uses that cuts out
DisplayConfigurator/DisplayChangeObserver/NativeDisplayDelegate.

That shouldn't be necessary for Config::MUS because we always use
DisplayConfigurator/DisplayChangeObserver/NativeDisplayDelegate. It's definitely
not necessary when running ./chrome --mus. We can accomplish similar off device
configuration with the --screen-config.

I think if ForwardingDisplayDelegate is connected in tests then it also wouldn't
be necessary for tests?

[sky, 2017/04/26 19:36:41]

I motivated the reason for this over IM.

+  if (config == Config::MUS && !display_initialized) {
+    // 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.
     display_configuration_controller_.reset(new DisplayConfigurationController(
         display_manager_.get(), window_tree_host_manager_.get()));
-
-#if defined(USE_OZONE)
-    display_configurator_->Init(
-        ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate(),
-        !gpu_support_->IsPanelFittingDisabled());
-#elif defined(USE_X11)
-    display_configurator_->Init(
-        base::MakeUnique<display::NativeDisplayDelegateX11>(),
-        !gpu_support_->IsPanelFittingDisabled());
-#endif
+    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());
 
-  if (!display_initialized && chromeos::IsRunningAsSystemCompositor()) {
+  // 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())) {
     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());
@@ skipping 158 matching lines @@
   SetSystemTrayDelegate(
       base::WrapUnique(shell_delegate_->CreateSystemTrayDelegate()));
 
   // May trigger initialization of the Bluetooth adapter.
   tray_bluetooth_helper_->Initialize();
 
   // Create AshTouchTransformController before
   // WindowTreeHostManager::InitDisplays()
   // since AshTouchTransformController listens on
   // WindowTreeHostManager::Observer::OnDisplaysInitialized().
-  if (config != Config::MASH) {
+  // TODO(sky): needs to to work for mus too.
+  if (config == Config::CLASSIC) {
     touch_transformer_controller_.reset(new AshTouchTransformController(
         display_configurator_.get(), display_manager_.get()));
   }
 
   keyboard_ui_ = shell_port_->CreateKeyboardUI();
 
   shell_port_->InitHosts(init_params);
 
   // Needs to be created after InitDisplays() since it may cause the virtual
   // keyboard to be deployed.
@@ skipping 179 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