Converts mash to use Shell

ash/common/wm_shell.h

 // 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.
 
 #ifndef ASH_COMMON_WM_SHELL_H_
 #define ASH_COMMON_WM_SHELL_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "ash/ash_export.h"
 #include "ash/common/metrics/gesture_action_type.h"
 #include "ash/common/metrics/user_metrics_action.h"
 #include "ash/common/session/session_state_observer.h"
 #include "ash/common/wm/lock_state_observer.h"
 #include "base/observer_list.h"
 #include "components/ui_devtools/devtools_server.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer_type.h"
+#include "ui/wm/public/activation_change_observer.h"
 #include "ui/wm/public/window_types.h"
 
 namespace app_list {
 class AppList;
 }
 
 namespace base {
 class SequencedWorkerPool;
 }
 
@@ skipping 36 matching lines @@
 class PaletteDelegate;
 class RootWindowController;
 class ScopedDisableInternalMouseAndKeyboard;
 class SessionController;
 class SessionStateDelegate;
 class ShelfController;
 class ShelfDelegate;
 class ShelfModel;
 class ShelfWindowWatcher;
 class ShellDelegate;
+struct ShellInitParams;
 class ShellObserver;
 class ShutdownController;
 class SystemTrayDelegate;
 class SystemTrayController;
 class SystemTrayNotifier;
 class ToastManager;
 class VpnList;
 class WallpaperController;
 class WallpaperDelegate;
 class WindowCycleController;
 class WindowCycleEventFilter;
 class WindowResizer;
 class WindowSelectorController;
 class WmActivationObserver;
 class WmDisplayObserver;
 class WmWindow;
 class WorkspaceEventHandler;
 
 enum class LoginStatus;
 enum class TaskSwitchSource;
 
 namespace wm {
 class MaximizeModeEventHandler;
 class WindowState;
 }
 
 // Similar to ash::Shell. Eventually the two will be merged.
-class ASH_EXPORT WmShell : public SessionStateObserver {
+class ASH_EXPORT WmShell : public SessionStateObserver,
+                           public aura::client::ActivationChangeObserver {
  public:
+  ~WmShell() override;
+
   // This is necessary for a handful of places that is difficult to plumb
   // through context.
   static void Set(WmShell* instance);
   static WmShell* Get();
   static bool HasInstance() { return instance_ != nullptr; }
 
-  void Initialize(const scoped_refptr<base::SequencedWorkerPool>& pool);
+  virtual void Initialize(const scoped_refptr<base::SequencedWorkerPool>& pool);
   virtual void Shutdown();
 
   ShellDelegate* delegate() { return delegate_.get(); }
 
   AcceleratorController* accelerator_controller() {
     return accelerator_controller_.get();
   }
 
   AccessibilityDelegate* accessibility_delegate() {
     return accessibility_delegate_.get();
@@ skipping 270 matching lines @@
   // Notify observers that |root_window|'s shelf changed auto-hide alignment.
   // TODO(jamescook): Move to Shelf.
   void NotifyShelfAlignmentChanged(WmWindow* root_window);
 
   // Notify observers that |root_window|'s shelf changed auto-hide behavior.
   // TODO(jamescook): Move to Shelf.
   void NotifyShelfAutoHideBehaviorChanged(WmWindow* root_window);
 
   virtual SessionStateDelegate* GetSessionStateDelegate() = 0;
 
-  virtual void AddActivationObserver(WmActivationObserver* observer) = 0;
-  virtual void RemoveActivationObserver(WmActivationObserver* observer) = 0;
+  void AddActivationObserver(WmActivationObserver* observer);
+  void RemoveActivationObserver(WmActivationObserver* observer);
 
   virtual void AddDisplayObserver(WmDisplayObserver* observer) = 0;
   virtual void RemoveDisplayObserver(WmDisplayObserver* observer) = 0;
 
   void AddShellObserver(ShellObserver* observer);
   void RemoveShellObserver(ShellObserver* observer);
 
   // If |events| is PointerWatcherEventTypes::MOVES,
   // PointerWatcher::OnPointerEventObserved() is called for pointer move events.
   // If |events| is PointerWatcherEventTypes::DRAGS,
@@ skipping 21 matching lines @@
 
   // True if any touch points are down.
   virtual bool IsTouchDown() = 0;
 
   // TODO(jamescook): Remove this when VirtualKeyboardController has been moved.
   virtual void ToggleIgnoreExternalKeyboard() = 0;
 
   // Enable or disable the laser pointer.
   virtual void SetLaserPointerEnabled(bool enabled) = 0;
 
+  virtual void CreatePointerWatcherAdapter() = 0;
+
  protected:
   explicit WmShell(std::unique_ptr<ShellDelegate> shell_delegate);
-  ~WmShell() override;
+
+  // Called during startup to create the primary WindowTreeHost and
+  // the corresponding RootWindowController.
+  virtual void CreatePrimaryHost() = 0;
+  virtual void InitHosts(const ShellInitParams& init_params) = 0;
 
   base::ObserverList<ShellObserver>* shell_observers() {
     return &shell_observers_;
   }
 
   void SetKeyboardUI(std::unique_ptr<KeyboardUI> keyboard_ui);
 
   // Helpers to set (and initialize) or destroy various delegates.
   // TODO(msw|jamescook): Remove these once ShellDelegate, etc. are ported.
   void SetSystemTrayDelegate(std::unique_ptr<SystemTrayDelegate> delegate);
@@ skipping 16 matching lines @@
 
   // SessionStateObserver:
   void SessionStateChanged(session_manager::SessionState state) override;
 
  private:
   friend class AcceleratorControllerTest;
   friend class ScopedRootWindowForNewWindows;
   friend class Shell;
   friend class WmShellTestApi;
 
+  // aura::client::ActivationChangeObserver:
+  void OnWindowActivated(ActivationReason reason,
+                         aura::Window* gained_active,
+                         aura::Window* lost_active) override;
+  void OnAttemptToReactivateWindow(aura::Window* request_active,
+                                   aura::Window* actual_active) override;
+
   static WmShell* instance_;
 
   base::ObserverList<ShellObserver> shell_observers_;
   std::unique_ptr<ShellDelegate> delegate_;
 
   scoped_refptr<preferences::PrefObserverStore> pref_store_;
 
   std::unique_ptr<AcceleratorController> accelerator_controller_;
   std::unique_ptr<AccessibilityDelegate> accessibility_delegate_;
   std::unique_ptr<app_list::AppList> app_list_;
@@ skipping 28 matching lines @@
   std::unique_ptr<ui::devtools::UiDevToolsServer> devtools_server_;
 
   base::ObserverList<LockStateObserver> lock_state_observers_;
 
   // See comment for GetRootWindowForNewWindows().
   WmWindow* root_window_for_new_windows_ = nullptr;
   WmWindow* scoped_root_window_for_new_windows_ = nullptr;
 
   bool simulate_modal_window_open_for_testing_ = false;
 
+  bool added_activation_observer_ = false;
+  base::ObserverList<WmActivationObserver> activation_observers_;
+
   scoped_refptr<base::SequencedWorkerPool> blocking_pool_;
 };
 
 }  // namespace ash
 
 #endif  // ASH_COMMON_WM_SHELL_H_