Moves maintaining root_window_for_new_windows_ to 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 63 matching lines @@
 
 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,
-                           public aura::client::ActivationChangeObserver {
+class ASH_EXPORT WmShell : public SessionStateObserver {
  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; }
 
   virtual void Initialize(const scoped_refptr<base::SequencedWorkerPool>& pool);
@@ skipping 38 matching lines @@
   }
 
   MruWindowTracker* mru_window_tracker() { return mru_window_tracker_.get(); }
 
   MediaController* media_controller() { return media_controller_.get(); }
 
   NewWindowController* new_window_controller() {
     return new_window_controller_.get();
   }
 
-  // NOTE: Prefer ScopedRootWindowForNewWindows when setting temporarily.
-  void set_root_window_for_new_windows(WmWindow* root) {
-    root_window_for_new_windows_ = root;
-  }
-
   PaletteDelegate* palette_delegate() { return palette_delegate_.get(); }
 
   preferences::PrefClientStore* pref_store() { return pref_store_.get(); }
 
   SessionController* session_controller() { return session_controller_.get(); }
 
   ShelfController* shelf_controller() { return shelf_controller_.get(); }
 
   ShelfDelegate* shelf_delegate() { return shelf_delegate_.get(); }
 
@@ skipping 49 matching lines @@
   virtual WmWindow* GetCaptureWindow() = 0;
 
   // Convenience for GetPrimaryRootWindow()->GetRootWindowController().
   RootWindowController* GetPrimaryRootWindowController();
 
   virtual WmWindow* GetPrimaryRootWindow() = 0;
 
   // Returns the root window for the specified display.
   virtual WmWindow* GetRootWindowForDisplayId(int64_t display_id) = 0;
 
-  // 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.
-  WmWindow* GetRootWindowForNewWindows();
-
   // Retuns the display info associated with |display_id|.
   // TODO(mash): Remove when DisplayManager has been moved. crbug.com/622480
   virtual const display::ManagedDisplayInfo& GetDisplayInfo(
       int64_t display_id) const = 0;
 
   // Matches that of DisplayManager::IsActiveDisplayId().
   // TODO(mash): Remove when DisplayManager has been moved. crbug.com/622480
   virtual bool IsActiveDisplayId(int64_t display_id) const = 0;
 
   // Returns true if the desktop is in unified mode and there are no mirroring
@@ skipping 223 matching lines @@
   void DeleteToastManager();
 
   void SetAcceleratorController(
       std::unique_ptr<AcceleratorController> accelerator_controller);
 
   // 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;
-
   static WmShell* instance_;
 
   base::ObserverList<ShellObserver> shell_observers_;
   std::unique_ptr<ShellDelegate> delegate_;
 
   scoped_refptr<preferences::PrefClientStore> pref_store_;
 
   std::unique_ptr<AcceleratorController> accelerator_controller_;
   std::unique_ptr<AccessibilityDelegate> accessibility_delegate_;
   std::unique_ptr<app_list::AppList> app_list_;
@@ skipping 22 matching lines @@
   std::unique_ptr<ToastManager> toast_manager_;
   std::unique_ptr<VpnList> vpn_list_;
   std::unique_ptr<WallpaperController> wallpaper_controller_;
   std::unique_ptr<WallpaperDelegate> wallpaper_delegate_;
   std::unique_ptr<WindowCycleController> window_cycle_controller_;
   std::unique_ptr<WindowSelectorController> window_selector_controller_;
   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;
 
   scoped_refptr<base::SequencedWorkerPool> blocking_pool_;
 };
 
 }  // namespace ash
 
 #endif  // ASH_COMMON_WM_SHELL_H_