Make WmShellMus use classic types for mus

ash/mus/bridge/wm_shell_mus.cc

 // Copyright 2016 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/mus/bridge/wm_shell_mus.h"
 
 #include <utility>
 
 #include "ash/accelerators/accelerator_controller_delegate_aura.h"
+#include "ash/aura/key_event_watcher_aura.h"
+#include "ash/aura/pointer_watcher_adapter.h"
 #include "ash/common/accelerators/accelerator_controller.h"
 #include "ash/common/key_event_watcher.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shell_delegate.h"
 #include "ash/common/shell_observer.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wallpaper/wallpaper_delegate.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_event_handler.h"
 #include "ash/common/wm/maximize_mode/scoped_disable_internal_mouse_and_keyboard.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/window_cycle_event_filter.h"
 #include "ash/common/wm/window_resizer.h"
 #include "ash/common/wm_window.h"
+#include "ash/laser/laser_pointer_controller.h"
+#include "ash/magnifier/partial_magnification_controller.h"
 #include "ash/mus/accelerators/accelerator_controller_delegate_mus.h"
 #include "ash/mus/accelerators/accelerator_controller_registrar.h"
 #include "ash/mus/bridge/immersive_handler_factory_mus.h"
 #include "ash/mus/bridge/workspace_event_handler_mus.h"
 #include "ash/mus/drag_window_resizer.h"
 #include "ash/mus/keyboard_ui_mus.h"
 #include "ash/mus/screen_mus.h"
 #include "ash/mus/window_manager.h"
 #include "ash/public/cpp/config.h"
 #include "ash/root_window_controller.h"
 #include "ash/root_window_settings.h"
 #include "ash/shared/immersive_fullscreen_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_init_params.h"
+#include "ash/touch/touch_uma.h"
+#include "ash/virtual_keyboard_controller.h"
+#include "ash/wm/drag_window_resizer.h"
+#include "ash/wm/maximize_mode/maximize_mode_event_handler_aura.h"
+#include "ash/wm/maximize_mode/scoped_disable_internal_mouse_and_keyboard_ozone.h"
+#include "ash/wm/window_cycle_event_filter_aura.h"
 #include "ash/wm/window_util.h"
+#include "ash/wm/workspace/workspace_event_handler_aura.h"
 #include "base/memory/ptr_util.h"
 #include "components/user_manager/user_info_impl.h"
+#include "ui/aura/env.h"
 #include "ui/aura/mus/window_tree_client.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
 #include "ui/aura/window.h"
 #include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/views/mus/pointer_watcher_event_router.h"
 #include "ui/wm/core/capture_controller.h"
 #include "ui/wm/core/focus_controller.h"
 
 namespace ash {
@@ skipping 66 matching lines @@
       return root_window_controller;
   }
   return nullptr;
 }
 
 aura::WindowTreeClient* WmShellMus::window_tree_client() {
   return window_manager_->window_tree_client();
 }
 
 void WmShellMus::Shutdown() {
+  pointer_watcher_adapter_.reset();
+
   WmShell::Shutdown();
 
   window_manager_->DeleteAllRootWindowControllers();
 }
 
 bool WmShellMus::IsRunningInMash() const {
   return GetConfig() == Config::MASH;
 }
 
 Config WmShellMus::GetConfig() const {
@@ skipping 98 matching lines @@
 std::vector<WmWindow*> WmShellMus::GetAllRootWindows() {
   std::vector<WmWindow*> root_windows;
   for (RootWindowController* root_window_controller :
        RootWindowController::root_window_controllers()) {
     root_windows.push_back(root_window_controller->GetWindow());
   }
   return root_windows;
 }
 
 void WmShellMus::RecordGestureAction(GestureActionType action) {
+  if (GetConfig() == Config::MUS) {
+    TouchUMA::GetInstance()->RecordGestureAction(action);
+    return;
+  }
   // TODO: http://crbug.com/616581.
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::RecordUserMetricsAction(UserMetricsAction action) {
+  if (GetConfig() == Config::MUS) {
+    Shell::GetInstance()->metrics()->RecordUserMetricsAction(action);

[msw, 2017/03/28 20:26:32]

Can MASH use this too, since it now instantiates and uses Shell?
(I know we'll need to use the metrics service eventually)
Similar question for other impls that just forward to Shell:
 RecordTaskSwitchMetric
 ToggleIgnoreExternalKeyboard
 SetLaserPointerEnabled
 SetPartialMagnifierEnabled

[sky, 2017/03/28 21:21:01]

Shell only creates UserMetricsRecorder in classic and mus modes. The keyboard is
specific to classic/mus, laser pointer may just work and I think magnification
is classic/mus specific.

+    return;
+  }
   // TODO: http://crbug.com/616581.
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::RecordTaskSwitchMetric(TaskSwitchSource source) {
+  if (GetConfig() == Config::MUS) {
+    Shell::GetInstance()
+        ->metrics()
+        ->task_switch_metrics_recorder()
+        .OnTaskSwitch(source);
+    return;
+  }
   // TODO: http://crbug.com/616581.
   NOTIMPLEMENTED();
 }
 
 std::unique_ptr<WindowResizer> WmShellMus::CreateDragWindowResizer(
     std::unique_ptr<WindowResizer> next_window_resizer,
     wm::WindowState* window_state) {
-  return base::MakeUnique<DragWindowResizer>(std::move(next_window_resizer),
-                                             window_state);
+  if (GetConfig() == Config::MUS) {
+    return base::WrapUnique(ash::DragWindowResizer::Create(
+        next_window_resizer.release(), window_state));
+  }
+  return base::MakeUnique<ash::mus::DragWindowResizer>(
+      std::move(next_window_resizer), window_state);
 }
 
 std::unique_ptr<WindowCycleEventFilter>
 WmShellMus::CreateWindowCycleEventFilter() {
+  if (GetConfig() == Config::MUS)
+    return base::MakeUnique<WindowCycleEventFilterAura>();
+
   // TODO: implement me, http://crbug.com/629191.
   return nullptr;
 }
 
 std::unique_ptr<wm::MaximizeModeEventHandler>
 WmShellMus::CreateMaximizeModeEventHandler() {
+  if (GetConfig() == Config::MUS)
+    return base::MakeUnique<wm::MaximizeModeEventHandlerAura>();
+
   // TODO: need support for window manager to get events before client:
   // http://crbug.com/624157.
   NOTIMPLEMENTED();
   return nullptr;
 }
 
 std::unique_ptr<ScopedDisableInternalMouseAndKeyboard>
 WmShellMus::CreateScopedDisableInternalMouseAndKeyboard() {
+  if (GetConfig() == Config::MUS) {
+#if defined(USE_OZONE)
+    return base::MakeUnique<ScopedDisableInternalMouseAndKeyboardOzone>();
+#else
+    // TODO: remove this conditional. Bots build this config, but it is never
+    // actually used.

[msw, 2017/03/28 20:26:32]

optional nit: cite a bug or actually create a
ScopedDisableInternalMouseAndKeyboardX11 like WmShellAura, so both can be fixed
simultaneously? (or maybe x11 is valid for non-mus chrome os?)

[sky, 2017/03/28 21:21:01]

x11 for chromeos isn't actually used anymore outside of bots. I added reference
to bug for removing the config.

+    NOTREACHED();
+    return nullptr;
+#endif
+  }
+
   // TODO: needs implementation for mus, http://crbug.com/624967.
   NOTIMPLEMENTED();
   return nullptr;
 }
 
 std::unique_ptr<WorkspaceEventHandler> WmShellMus::CreateWorkspaceEventHandler(
     WmWindow* workspace_window) {
+  if (GetConfig() == Config::MUS)
+    return base::MakeUnique<WorkspaceEventHandlerAura>(workspace_window);
+
   return base::MakeUnique<WorkspaceEventHandlerMus>(
       WmWindow::GetAuraWindow(workspace_window));
 }
 
 std::unique_ptr<ImmersiveFullscreenController>
 WmShellMus::CreateImmersiveFullscreenController() {
   return base::MakeUnique<ImmersiveFullscreenController>();
 }
 
 std::unique_ptr<KeyboardUI> WmShellMus::CreateKeyboardUI() {
+  if (GetConfig() == Config::MUS)
+    return KeyboardUI::Create();
+
   return KeyboardUIMus::Create(window_manager_->connector());
 }
 
 std::unique_ptr<KeyEventWatcher> WmShellMus::CreateKeyEventWatcher() {
+  if (GetConfig() == Config::MUS)
+    return base::MakeUnique<KeyEventWatcherAura>();
+
   // TODO: needs implementation for mus, http://crbug.com/649600.
   NOTIMPLEMENTED();
   return std::unique_ptr<KeyEventWatcher>();
 }
 
 SessionStateDelegate* WmShellMus::GetSessionStateDelegate() {
   return session_state_delegate_
              ? session_state_delegate_.get()
              : Shell::GetInstance()->session_state_delegate();
 }
 
 void WmShellMus::AddDisplayObserver(WmDisplayObserver* observer) {
+  // TODO: need WmDisplayObserver support for mus. http://crbug.com/705831.
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::RemoveDisplayObserver(WmDisplayObserver* observer) {
+  // TODO: need WmDisplayObserver support for mus. http://crbug.com/705831.
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::AddPointerWatcher(views::PointerWatcher* watcher,
                                    views::PointerWatcherEventTypes events) {
+  if (GetConfig() == Config::MUS) {
+    pointer_watcher_adapter_->AddPointerWatcher(watcher, events);
+    return;
+  }
+
   // TODO: implement drags for mus pointer watcher, http://crbug.com/641164.
   // NOTIMPLEMENTED drags for mus pointer watcher.
   pointer_watcher_event_router_->AddPointerWatcher(
       watcher, events == views::PointerWatcherEventTypes::MOVES);
 }
 
 void WmShellMus::RemovePointerWatcher(views::PointerWatcher* watcher) {
+  if (GetConfig() == Config::MUS) {
+    pointer_watcher_adapter_->RemovePointerWatcher(watcher);
+    return;
+  }
+
   pointer_watcher_event_router_->RemovePointerWatcher(watcher);
 }
 
 bool WmShellMus::IsTouchDown() {
+  if (GetConfig() == Config::MUS)
+    return aura::Env::GetInstance()->is_touch_down();
+
   // TODO: implement me, http://crbug.com/634967.
   // NOTIMPLEMENTED is too spammy here.
   return false;
 }
 
 void WmShellMus::ToggleIgnoreExternalKeyboard() {
+  if (GetConfig() == Config::MUS) {
+    Shell::GetInstance()
+        ->virtual_keyboard_controller()
+        ->ToggleIgnoreExternalKeyboard();
+    return;
+  }
+
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::SetLaserPointerEnabled(bool enabled) {
+  if (GetConfig() == Config::MUS) {
+    Shell::GetInstance()->laser_pointer_controller()->SetEnabled(enabled);
+    return;
+  }
+
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::SetPartialMagnifierEnabled(bool enabled) {
+  if (GetConfig() == Config::MUS) {
+    Shell::GetInstance()->partial_magnification_controller()->SetEnabled(
+        enabled);
+    return;
+  }
+
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::CreatePointerWatcherAdapter() {
-  // Only needed in WmShellAura, which has specific creation order.
+  // In Config::MUS PointerWatcherAdapter must be created when this function is
+  // caled (it is order dependent), that is not the case with Config::MASH.

[msw, 2017/03/28 20:26:32]

nit: called

[sky, 2017/03/28 21:21:01]

Done.

+  if (GetConfig() == Config::MUS)
+    pointer_watcher_adapter_ = base::MakeUnique<PointerWatcherAdapter>();
 }
 
 void WmShellMus::CreatePrimaryHost() {}
 
 void WmShellMus::InitHosts(const ShellInitParams& init_params) {
   window_manager_->CreatePrimaryRootWindowController(
       base::WrapUnique(init_params.primary_window_tree_host));
 }
 
 std::unique_ptr<AcceleratorController>
@@ skipping 18 matching lines @@
   accelerator_controller_registrar_ =
       base ::MakeUnique<AcceleratorControllerRegistrar>(
           window_manager_, accelerator_namespace_id);
   return base::MakeUnique<AcceleratorController>(
       accelerator_controller_delegate_.get(),
       accelerator_controller_registrar_.get());
 }
 
 }  // namespace mus
 }  // namespace ash