mash: Migrate ScopedTargetRootWindow to //ash/common

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/common/shelf/shelf_types.h"
 #include "ash/metrics/user_metrics_recorder.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/base/ui_base_types.h"
 #include "ui/display/screen.h"
 #include "ui/events/event_target.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/wm/core/cursor_manager.h"
-#include "ui/wm/public/activation_change_observer.h"
 
 namespace aura {
 class EventFilter;
 class RootWindow;
 class Window;
 namespace client {
 class ActivationClient;
 class FocusClient;
 }
 }
@@ skipping 65 matching lines @@
 class OverlayEventFilter;
 class PartialMagnificationController;
 class PointerWatcherDelegate;
 class PowerButtonController;
 class PowerEventObserver;
 class ProjectingObserver;
 class ResizeShadowController;
 class ResolutionNotificationController;
 class RootWindowController;
 class ScopedOverviewAnimationSettingsFactoryAura;
-class ScopedTargetRootWindow;
 class ScreenAsh;
 class ScreenOrientationController;
 class ScreenshotController;
 class ScreenPinningController;
 class ScreenPositionController;
 class SessionStateDelegate;
 class Shelf;
 class ShelfWindowWatcher;
 class ShellDelegate;
 struct ShellInitParams;
@@ skipping 22 matching lines @@
 namespace test {
 class ShellTestApi;
 }
 
 // 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 aura::client::ActivationChangeObserver {
+                         public ui::EventTarget {
  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 10 matching lines @@
   // 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 ScopedTargetRootWindow().
+  // 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 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);
 
   // Returns the list of containers that match |container_id| in
   // all root windows. If |priority_root| is given, the container
   // in the |priority_root| will be inserted at the top of the list.
   static std::vector<aura::Window*> GetContainersFromAllRootWindows(
       int container_id,
       aura::Window* priority_root);
 
-  void set_target_root_window(aura::Window* target_root_window) {
-    target_root_window_ = target_root_window;
-  }
-
   // Shows the context menu for the background and launcher at
   // |location_in_screen| (in screen coordinates).
   void ShowContextMenu(const gfx::Point& location_in_screen,
                        ui::MenuSourceType source_type);
 
   // Creates a default views::NonClientFrameView for use by windows in the
   // Ash environment.
   views::NonClientFrameView* CreateDefaultNonClientFrameView(
       views::Widget* widget);
 
@@ skipping 246 matching lines @@
     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 ScopedTargetRootWindow;
   friend class test::ShellTestApi;
   friend class shell::WindowWatcher;
 
   typedef std::pair<aura::Window*, gfx::Rect> WindowAndBoundsPair;
 
   // Takes ownership of |delegate|.
   Shell(ShellDelegate* delegate, base::SequencedWorkerPool* blocking_pool);
   ~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);
 
   // Prepares the shelf to be deleted.
   void ShutdownShelf();
 
   // 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;
 
-  // Overridden from aura::client::ActivationChangeObserver:
-  void OnWindowActivated(
-      aura::client::ActivationChangeObserver::ActivationReason reason,
-      aura::Window* gained_active,
-      aura::Window* lost_active) override;
-
   static Shell* instance_;
 
   // If set before the Shell is initialized, the mouse cursor will be hidden
   // when the screen is initially created.
   static bool initially_hide_cursor_;
 
   std::unique_ptr<ScopedOverviewAnimationSettingsFactoryAura>
       scoped_overview_animation_settings_factory_;
   std::unique_ptr<WmShellAura> wm_shell_;
 
-  // When no explicit target display/RootWindow is given, new windows are
-  // created on |scoped_target_root_window_| , unless NULL in
-  // which case they are created on |target_root_window_|.
-  // |target_root_window_| never becomes NULL during the session.
-  aura::Window* target_root_window_;
-  aura::Window* scoped_target_root_window_;
-
   // The CompoundEventFilter owned by aura::Env object.
   std::unique_ptr<::wm::CompoundEventFilter> env_filter_;
 
   std::vector<WindowAndBoundsPair> to_restore_;
 
   std::unique_ptr<UserMetricsRecorder> user_metrics_recorder_;
   std::unique_ptr<AcceleratorControllerDelegateAura>
       accelerator_controller_delegate_;
   std::unique_ptr<UserWallpaperDelegate> user_wallpaper_delegate_;
   std::unique_ptr<SessionStateDelegate> session_state_delegate_;
@@ skipping 99 matching lines @@
   base::SequencedWorkerPool* blocking_pool_;
 
   bool in_mus_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(Shell);
 };
 
 }  // namespace ash
 
 #endif  // ASH_SHELL_H_