mash: Port KeyboardUIMus to mojo:ash; remove sysui.

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 152 matching lines @@
  private:
   // Overridden from ::wm::VisibilityController:
   bool CallAnimateOnChildWindowVisibilityChanged(aura::Window* window,
                                                  bool visible) override {
     return AnimateOnChildWindowVisibilityChanged(window, visible);
   }
 
   DISALLOW_COPY_AND_ASSIGN(AshVisibilityController);
 };
 
-AshWindowTreeHostInitParams ShellInitParamsToAshWindowTreeHostInitParams(
-    const ShellInitParams& shell_init_params) {
-  AshWindowTreeHostInitParams ash_init_params;
-#if defined(OS_WIN)
-  ash_init_params.remote_hwnd = shell_init_params.remote_hwnd;
-#endif
-  return ash_init_params;
-}
-
 }  // namespace
 
 // static
 Shell* Shell::instance_ = nullptr;
 // static
 bool Shell::initially_hide_cursor_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
@@ skipping 141 matching lines @@
   DCHECK_GT(session_state_delegate_->NumberOfLoggedInUsers(), 0);
   wm_shell_->CreateShelfDelegate();
 
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
     (*iter)->CreateShelf();
 }
 
 void Shell::CreateKeyboard() {
-  if (in_mus_)
-    return;
   // TODO(bshe): Primary root window controller may not be the controller to
   // attach virtual keyboard. See http://crbug.com/303429
   InitKeyboard();
   GetPrimaryRootWindowController()->ActivateKeyboard(
       keyboard::KeyboardController::GetInstance());
 }
 
 void Shell::DeactivateKeyboard() {
   // TODO(jamescook): Move keyboard create and hide into WmShell.
   wm_shell_->keyboard_ui()->Hide();
-  if (in_mus_)
-    return;
   if (keyboard::KeyboardController::GetInstance()) {
     RootWindowControllerList controllers = GetAllRootWindowControllers();
     for (RootWindowControllerList::iterator iter = controllers.begin();
          iter != controllers.end(); ++iter) {
       (*iter)->DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
     }
   }
   keyboard::KeyboardController::ResetInstance(nullptr);
 }
 
@@ skipping 246 matching lines @@
   // Needs to happen right before |instance_| is reset.
   wm_shell_.reset();
 
   DCHECK(instance_ == this);
   instance_ = nullptr;
 }
 
 void Shell::Init(const ShellInitParams& init_params) {
   wm_shell_->Initialize(init_params.blocking_pool);
 
-  in_mus_ = init_params.in_mus;
-
   immersive_handler_factory_ = base::MakeUnique<ImmersiveHandlerFactoryAsh>();
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
-  DCHECK(in_mus_) << "linux desktop does not support ash.";
+  NOTREACHED() << "linux desktop does not support ash.";
 #endif
 
   scoped_overview_animation_settings_factory_.reset(
       new ScopedOverviewAnimationSettingsFactoryAura);
   window_positioner_.reset(new WindowPositioner(wm_shell_.get()));
 
-  if (!in_mus_) {
-    native_cursor_manager_ = new AshNativeCursorManager;
+  native_cursor_manager_ = new AshNativeCursorManager;
 #if defined(OS_CHROMEOS)
-    cursor_manager_.reset(
-        new CursorManager(base::WrapUnique(native_cursor_manager_)));
+  cursor_manager_.reset(
+      new CursorManager(base::WrapUnique(native_cursor_manager_)));
 #else
-    cursor_manager_.reset(
-        new ::wm::CursorManager(base::WrapUnique(native_cursor_manager_)));
+  cursor_manager_.reset(
+      new ::wm::CursorManager(base::WrapUnique(native_cursor_manager_)));
 #endif
-  }
 
   wm_shell_->delegate()->PreInit();
   bool display_initialized = display_manager_->InitFromCommandLine();
 
   display_configuration_controller_.reset(new DisplayConfigurationController(
       display_manager_.get(), window_tree_host_manager_.get()));
 
 #if defined(OS_CHROMEOS)
-  // When running as part of mash display configuration is handled by the mus
-  // process, so we won't try to configure displays here.
-  if (in_mus_) {
-    display_configurator_->set_configure_display(false);
-  } else {
+
 #if defined(USE_OZONE)
-    display_configurator_->Init(
-        ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate(),
-        !gpu_support_->IsPanelFittingDisabled());
+  display_configurator_->Init(
+      ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate(),
+      !gpu_support_->IsPanelFittingDisabled());
 #elif defined(USE_X11)
-    display_configurator_->Init(
-        base::MakeUnique<ui::NativeDisplayDelegateX11>(),
-        !gpu_support_->IsPanelFittingDisabled());
+  display_configurator_->Init(base::MakeUnique<ui::NativeDisplayDelegateX11>(),
+                              !gpu_support_->IsPanelFittingDisabled());
 #endif
-  }
 
   // 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());
   wm_shell_->AddShellObserver(projecting_observer_.get());
 
-  if (!in_mus_ && !display_initialized &&
-      base::SysInfo::IsRunningOnChromeOS()) {
+  if (!display_initialized && base::SysInfo::IsRunningOnChromeOS()) {
     display_change_observer_.reset(new DisplayChangeObserver);
     // 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(
         wm_shell_->delegate()->IsFirstRunAfterBoot() ? kChromeOsBootColor : 0);
@@ skipping 21 matching lines @@
   wm::AshFocusRules* focus_rules = new wm::AshFocusRules();
 
   ::wm::FocusController* focus_controller =
       new ::wm::FocusController(focus_rules);
   focus_client_.reset(focus_controller);
   activation_client_ = focus_controller;
 
   screen_position_controller_.reset(new ScreenPositionController);
 
   window_tree_host_manager_->Start();
-  window_tree_host_manager_->CreatePrimaryHost(
-      ShellInitParamsToAshWindowTreeHostInitParams(init_params));
+  AshWindowTreeHostInitParams ash_init_params;
+  window_tree_host_manager_->CreatePrimaryHost(ash_init_params);
   aura::Window* root_window = window_tree_host_manager_->GetPrimaryRootWindow();
   wm_shell_->set_root_window_for_new_windows(WmWindowAura::Get(root_window));
 
 #if defined(OS_CHROMEOS)
   resolution_notification_controller_.reset(
       new ResolutionNotificationController);
 #endif
 
   if (cursor_manager_)
     cursor_manager_->SetDisplay(
@@ skipping 104 matching lines @@
   wm_shell_->SetSystemTrayDelegate(
       base::WrapUnique(wm_shell_->delegate()->CreateSystemTrayDelegate()));
 
   locale_notification_controller_.reset(new LocaleNotificationController);
 
 #if defined(OS_CHROMEOS)
   // Create TouchTransformerController before
   // WindowTreeHostManager::InitDisplays()
   // since TouchTransformerController listens on
   // WindowTreeHostManager::Observer::OnDisplaysInitialized().
-  if (!in_mus_)
-    touch_transformer_controller_.reset(new TouchTransformerController());
+  touch_transformer_controller_.reset(new TouchTransformerController());
 #endif  // defined(OS_CHROMEOS)
 
-  wm_shell_->SetKeyboardUI(init_params.keyboard_factory.is_null()
-                               ? KeyboardUI::Create()
-                               : init_params.keyboard_factory.Run());
+  wm_shell_->SetKeyboardUI(KeyboardUI::Create());
 
   window_tree_host_manager_->InitHosts();
 
 #if defined(OS_CHROMEOS)
   // Needs to be created after InitDisplays() since it may cause the virtual
   // keyboard to be deployed.
   virtual_keyboard_controller_.reset(new VirtualKeyboardController);
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(OS_CHROMEOS)
@@ skipping 26 matching lines @@
   // is started.
   display_manager_->CreateMirrorWindowAsyncIfAny();
 
   FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnShellInitialized());
 
   user_metrics_recorder_->OnShellInitialized();
 }
 
 void Shell::InitKeyboard() {
-  if (in_mus_)
-    return;
-
   if (keyboard::IsKeyboardEnabled()) {
     if (keyboard::KeyboardController::GetInstance()) {
       RootWindowControllerList controllers = GetAllRootWindowControllers();
       for (RootWindowControllerList::iterator iter = controllers.begin();
            iter != controllers.end(); ++iter) {
         (*iter)->DeactivateKeyboard(
             keyboard::KeyboardController::GetInstance());
       }
     }
     keyboard::KeyboardController::ResetInstance(
@@ skipping 49 matching lines @@
 std::unique_ptr<ui::EventTargetIterator> Shell::GetChildIterator() const {
   return std::unique_ptr<ui::EventTargetIterator>();
 }
 
 ui::EventTargeter* Shell::GetEventTargeter() {
   NOTREACHED();
   return nullptr;
 }
 
 }  // namespace ash