Moves maintaining root_window_for_new_windows_ to Shell

ash/shell.h

 // 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.
 
 #ifndef ASH_SHELL_H_
 #define ASH_SHELL_H_
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "ash/ash_export.h"
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/public/cpp/shelf_types.h"
 #include "ash/wm/cursor_manager_chromeos.h"
 #include "ash/wm/system_modal_container_event_filter_delegate.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "ui/aura/window.h"
 #include "ui/display/screen.h"
 #include "ui/events/event_target.h"
 #include "ui/wm/core/cursor_manager.h"
+#include "ui/wm/public/activation_change_observer.h"
 
 namespace aura {
 class RootWindow;
 class UserActivityForwarder;
 class Window;
 class WindowManagerClient;
 class WindowTreeClient;
 namespace client {
 class ActivationClient;
-class FocusClient;
 }
 }
 
 namespace chromeos {
 class AudioA11yController;
 }
 
 namespace display {
 class DisplayChangeObserver;
 class DisplayConfigurator;
@@ skipping 13 matching lines @@
 class NonClientFrameView;
 class Widget;
 namespace corewm {
 class TooltipController;
 }
 }
 
 namespace wm {
 class AcceleratorFilter;
 class CompoundEventFilter;
+class FocusController;
 class ShadowController;
 class VisibilityController;
 class WindowModalityController;
 }
 
 namespace ash {
 
 class AcceleratorControllerDelegateAura;
 class AppListDelegateImpl;
 class AshNativeCursorManager;
@@ skipping 56 matching lines @@
 class ShellTestApi;
 class SmsObserverTest;
 }
 
 // Shell is a singleton object that presents the Shell API and implements the
 // RootWindow's delegate interface.
 //
 // Upon creation, the Shell sets itself as the RootWindow's delegate, which
 // takes ownership of the Shell.
 class ASH_EXPORT Shell : public SystemModalContainerEventFilterDelegate,
-                         public ui::EventTarget {
+                         public ui::EventTarget,
+                         public aura::client::ActivationChangeObserver {
  public:
   typedef std::vector<RootWindowController*> RootWindowControllerList;
 
   // A shell must be explicitly created so that it can call |Init()| with the
   // delegate set. |delegate| can be NULL (if not required for initialization).
   // Takes ownership of |delegate|.
   static Shell* CreateInstance(const ShellInitParams& init_params);
 
   // Should never be called before |CreateInstance()|.
   static Shell* GetInstance();
@@ skipping 13 matching lines @@
       int64_t display_id);
 
   // Returns all root window controllers.
   // TODO(oshima): move this to |RootWindowController|
   static RootWindowControllerList GetAllRootWindowControllers();
 
   // Returns the primary root Window. The primary root Window is the one that
   // has a launcher.
   static aura::Window* GetPrimaryRootWindow();
 
-  // Returns a root Window when used as a target when creating a new window.
-  // The root window of the active window is used in most cases, but can
-  // be overridden by using ScopedRootWindowForNewWindows.
-  // If you want to get the root Window of the active window, just use
-  // |wm::GetActiveWindow()->GetRootWindow()|.
-  static aura::Window* GetTargetRootWindow();
-
-  // Returns the id of the display::Display corresponding to the window returned
-  // by |GetTargetRootWindow()|
-  static int64_t GetTargetDisplayId();
+  // Returns the root window that newly created windows should be added to.
+  // Value can be temporarily overridden using ScopedRootWindowForNewWindows.
+  // NOTE: this returns the root, newly created window should be added to the
+  // appropriate container in the returned window.
+  static aura::Window* GetRootWindowForNewWindows();
+  static WmWindow* GetWmRootWindowForNewWindows();
 
   // Returns all root windows.
   static aura::Window::Windows GetAllRootWindows();
 
   static aura::Window* GetContainer(aura::Window* root_window,
                                     int container_id);
   static const aura::Window* GetContainer(const aura::Window* root_window,
                                           int container_id);
 
   // TODO(sky): move this and WindowManagerClient into ShellMash that is owned
@@ skipping 113 matching lines @@
   }
 
   MagnificationController* magnification_controller() {
     return magnification_controller_.get();
   }
 
   AutoclickController* autoclick_controller() {
     return autoclick_controller_.get();
   }
 
-  aura::client::ActivationClient* activation_client() {
-    return activation_client_;
-  }
+  aura::client::ActivationClient* activation_client();
 
   // Force the shelf to query for it's current visibility state.
   // TODO(jamescook): Move to Shelf.
   void UpdateShelfVisibility();
 
   // Returns WebNotificationTray on the primary root window.
   WebNotificationTray* GetWebNotificationTray();
 
   // Does the primary display have status area?
   bool HasPrimaryStatusArea();
@@ skipping 48 matching lines @@
   WindowPositioner* window_positioner() { return window_positioner_.get(); }
 
   UserMetricsRecorder* metrics() { return user_metrics_recorder_.get(); }
 
   void SetTouchHudProjectionEnabled(bool enabled);
 
   bool is_touch_hud_projection_enabled() const {
     return is_touch_hud_projection_enabled_;
   }
 
+  // NOTE: Prefer ScopedRootWindowForNewWindows when setting temporarily.
+  void set_root_window_for_new_windows(WmWindow* root) {
+    root_window_for_new_windows_ = root;
+  }
+
   // Creates instance of FirstRunHelper. Caller is responsible for deleting
   // returned object.
   ash::FirstRunHelper* CreateFirstRunHelper();
 
   void SetLargeCursorSizeInDip(int large_cursor_size_in_dip);
 
   // Toggles cursor compositing on/off. Native cursor is disabled when cursor
   // compositing is enabled, and vice versa.
   void SetCursorCompositingEnabled(bool enabled);
 
   StickyKeysController* sticky_keys_controller() {
     return sticky_keys_controller_.get();
   }
 
   ScreenPinningController* screen_pinning_controller() {
     return screen_pinning_controller_.get();
   }
 
   GPUSupport* gpu_support() { return gpu_support_.get(); }
 
  private:
   FRIEND_TEST_ALL_PREFIXES(ExtendedDesktopTest, TestCursor);
   FRIEND_TEST_ALL_PREFIXES(WindowManagerTest, MouseEventCursors);
   FRIEND_TEST_ALL_PREFIXES(WindowManagerTest, TransformActivate);
   friend class RootWindowController;
+  friend class ScopedRootWindowForNewWindows;
+  friend class SmsObserverTest;
   friend class test::ShellTestApi;
   friend class shell::WindowWatcher;
-  friend class SmsObserverTest;
 
   explicit Shell(std::unique_ptr<WmShell> wm_shell);
   ~Shell() override;
 
   void Init(const ShellInitParams& init_params);
 
   // Initializes virtual keyboard controller.
   void InitKeyboard();
 
   // Initializes the root window so that it can host browser windows.
   void InitRootWindow(aura::Window* root_window);
 
   // Destroys all child windows including widgets across all roots.
   void CloseAllRootWindowChildWindows();
 
   // SystemModalContainerEventFilterDelegate:
   bool CanWindowReceiveEvents(aura::Window* window) override;
 
   // Overridden from ui::EventTarget:
   bool CanAcceptEvent(const ui::Event& event) override;
   EventTarget* GetParentTarget() override;
   std::unique_ptr<ui::EventTargetIterator> GetChildIterator() const override;
   ui::EventTargeter* GetEventTargeter() override;
 
+  // aura::client::ActivationChangeObserver:
+  void OnWindowActivated(ActivationReason reason,
+                         aura::Window* gained_active,
+                         aura::Window* lost_active) override;
+
   static Shell* instance_;
 
   // Only valid in mash, for classic ash this is null.
   static aura::WindowTreeClient* window_tree_client_;
   static aura::WindowManagerClient* window_manager_client_;
 
   // If set before the Shell is initialized, the mouse cursor will be hidden
   // when the screen is initially created.
   static bool initially_hide_cursor_;
 
@@ skipping 18 matching lines @@
   std::unique_ptr<views::corewm::TooltipController> tooltip_controller_;
   LinkHandlerModelFactory* link_handler_model_factory_;
   std::unique_ptr<PowerButtonController> power_button_controller_;
   std::unique_ptr<LockStateController> lock_state_controller_;
   std::unique_ptr<ui::UserActivityDetector> user_activity_detector_;
   std::unique_ptr<VideoDetector> video_detector_;
   std::unique_ptr<WindowTreeHostManager> window_tree_host_manager_;
   std::unique_ptr<HighContrastController> high_contrast_controller_;
   std::unique_ptr<MagnificationController> magnification_controller_;
   std::unique_ptr<AutoclickController> autoclick_controller_;
-  std::unique_ptr<aura::client::FocusClient> focus_client_;
-
-  aura::client::ActivationClient* activation_client_;
+  std::unique_ptr<::wm::FocusController> focus_controller_;
 
   std::unique_ptr<ScreenshotController> screenshot_controller_;
 
   std::unique_ptr<MouseCursorEventFilter> mouse_cursor_filter_;
   std::unique_ptr<ScreenPositionController> screen_position_controller_;
   std::unique_ptr<SystemModalContainerEventFilter> modality_filter_;
   std::unique_ptr<EventClientImpl> event_client_;
   std::unique_ptr<EventTransformationHandler> event_transformation_handler_;
 
   // An event filter that pre-handles key events while the partial
@@ skipping 62 matching lines @@
 
   // Cursor may be hidden on certain key events in Chrome OS, whereas we never
   // hide the cursor on Windows.
   std::unique_ptr<::wm::CursorManager> cursor_manager_;
 
   // For testing only: simulate that a modal window is open
   bool simulate_modal_window_open_for_testing_;
 
   bool is_touch_hud_projection_enabled_;
 
+  // See comment for GetWmRootWindowForNewWindows().
+  WmWindow* root_window_for_new_windows_ = nullptr;
+  WmWindow* scoped_root_window_for_new_windows_ = nullptr;
+
   // Injected content::GPUDataManager support.
   std::unique_ptr<GPUSupport> gpu_support_;
 
   std::unique_ptr<ImmersiveHandlerFactoryAsh> immersive_handler_factory_;
 
   std::unique_ptr<AppListDelegateImpl> app_list_delegate_impl_;
 
   DISALLOW_COPY_AND_ASSIGN(Shell);
 };
 
 }  // namespace ash
 
 #endif  // ASH_SHELL_H_