Promotes remaining global window manager state into WindowManagerState

components/mus/ws/display.h

 // Copyright 2015 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 COMPONENTS_MUS_WS_DISPLAY_H_
 #define COMPONENTS_MUS_WS_DISPLAY_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 15 matching lines @@
 #include "components/mus/ws/user_id_tracker_observer.h"
 #include "components/mus/ws/window_manager_window_tree_factory_set_observer.h"
 
 namespace mus {
 namespace ws {
 
 class DisplayBinding;
 class DisplayManager;
 class FocusController;
 struct PlatformDisplayInitParams;
-class WindowManagerState;
+class WindowManagerDisplayRoot;
 class WindowServer;
 class WindowTree;
 
 namespace test {
 class DisplayTestApi;
 }
 
 // Displays manages the state associated with a single display. Display has a
 // single root window whose children are the roots for a per-user
 // WindowManager. Display is configured in two distinct
@@ skipping 16 matching lines @@
   ~Display() override;
 
   // Initializes state that depends on the existence of a Display.
   void Init(std::unique_ptr<DisplayBinding> binding);
 
   uint32_t id() const { return id_; }
 
   DisplayManager* display_manager();
   const DisplayManager* display_manager() const;
 
+  PlatformDisplay* platform_display() { return platform_display_.get(); }
+
   // Returns a mojom::Display for the specified display. WindowManager specific
-  // values are not set. In general you should use
-  // WindowManagerState::ToMojomDisplay().
+  // values are not set.
   mojom::DisplayPtr ToMojomDisplay() const;
 
   // Schedules a paint for the specified region in the coordinates of |window|.
   void SchedulePaint(const ServerWindow* window, const gfx::Rect& bounds);
 
   // Schedules destruction of surfaces in |window|. If a frame has been
   // scheduled but not drawn surface destruction is delayed until the frame is
   // drawn, otherwise destruction is immediate.
   void ScheduleSurfaceDestruction(ServerWindow* window);
 
   mojom::Rotation GetRotation() const;
   gfx::Size GetSize() const;
 
   // Returns the id for the corresponding id.
   int64_t GetPlatformDisplayId() const;
 
   WindowServer* window_server() { return window_server_; }
 
   // Returns the root of the Display. The root's children are the roots
   // of the corresponding WindowManagers.
   ServerWindow* root_window() { return root_.get(); }
   const ServerWindow* root_window() const { return root_.get(); }
 
+  // Returns the ServerWindow whose id is |id|. This does not do a search over
+  // all windows, rather just the display and window manager root windows.
+  //
+  // In general you shouldn't use this, rather use WindowServer::GetWindow(),
+  // which calls this as necessary.
   ServerWindow* GetRootWithId(const WindowId& id);
 
-  WindowManagerState* GetWindowManagerStateWithRoot(const ServerWindow* window);
-  WindowManagerState* GetWindowManagerStateForUser(const UserId& user_id) {
-    return const_cast<WindowManagerState*>(
-        const_cast<const Display*>(this)->GetWindowManagerStateForUser(
+  WindowManagerDisplayRoot* GetWindowManagerDisplayRootWithRoot(
+      const ServerWindow* window);
+  WindowManagerDisplayRoot* GetWindowManagerDisplayRootForUser(
+      const UserId& user_id) {
+    return const_cast<WindowManagerDisplayRoot*>(
+        const_cast<const Display*>(this)->GetWindowManagerDisplayRootForUser(
             user_id));
   }
-  const WindowManagerState* GetWindowManagerStateForUser(
+  const WindowManagerDisplayRoot* GetWindowManagerDisplayRootForUser(
       const UserId& user_id) const;
-  WindowManagerState* GetActiveWindowManagerState() {
-    return const_cast<WindowManagerState*>(
-        const_cast<const Display*>(this)->GetActiveWindowManagerState());
+  WindowManagerDisplayRoot* GetActiveWindowManagerDisplayRoot() {
+    return const_cast<WindowManagerDisplayRoot*>(
+        const_cast<const Display*>(this)->GetActiveWindowManagerDisplayRoot());
   }
-  const WindowManagerState* GetActiveWindowManagerState() const;
+  const WindowManagerDisplayRoot* GetActiveWindowManagerDisplayRoot() const;
   size_t num_window_manger_states() const {
-    return window_manager_state_map_.size();
+    return window_manager_display_root_map_.size();
   }
 
   // TODO(sky): this should only be called by WindowServer, move to interface
   // used by WindowServer.
   // See description of WindowServer::SetFocusedWindow() for details on return
   // value.
   bool SetFocusedWindow(ServerWindow* window);
   // NOTE: this returns the focused window only if the focused window is in this
   // display. If this returns null focus may be in another display.
   ServerWindow* GetFocusedWindow();
@@ skipping 12 matching lines @@
 
   void UpdateNativeCursor(int32_t cursor_id);
 
   // mojom::WindowTreeHost:
   void SetSize(const gfx::Size& size) override;
   void SetTitle(const mojo::String& title) override;
 
  private:
   friend class test::DisplayTestApi;
 
-  using WindowManagerStateMap =
-      std::map<UserId, std::unique_ptr<WindowManagerState>>;
+  using WindowManagerDisplayRootMap =
+      std::map<UserId, std::unique_ptr<WindowManagerDisplayRoot>>;
 
   // Inits the necessary state once the display is ready.
-  void InitWindowManagersIfNecessary();
+  void InitWindowManagerDisplayRootsIfNecessary();
 
-  // Creates the set of WindowManagerStates from the
+  // Creates the set of WindowManagerDisplayRoots from the
   // WindowManagerWindowTreeFactorySet.
-  void CreateWindowManagerStatesFromFactories();
+  void CreateWindowManagerDisplayRootsFromFactories();
 
-  void CreateWindowManagerStateFromFactory(
+  void CreateWindowManagerDisplayRootFromFactory(
       WindowManagerWindowTreeFactory* factory);
 
   // PlatformDisplayDelegate:
   ServerWindow* GetRootWindow() override;
   void OnEvent(const ui::Event& event) override;
   void OnNativeCaptureLost() override;
   void OnDisplayClosed() override;
   void OnViewportMetricsChanged(const ViewportMetrics& old_metrics,
                                 const ViewportMetrics& new_metrics) override;
   void OnCompositorFrameDrawn() override;
 
   // FocusControllerDelegate:
   bool CanHaveActiveChildren(ServerWindow* window) const override;
 
   // FocusControllerObserver:
   void OnActivationChanged(ServerWindow* old_active_window,
                            ServerWindow* new_active_window) override;
   void OnFocusChanged(FocusControllerChangeSource change_source,
                       ServerWindow* old_focused_window,
                       ServerWindow* new_focused_window) override;
 
   // ServerWindowObserver:
   void OnWindowDestroyed(ServerWindow* window) override;
 
   // UserIdTrackerObserver:
-  void OnActiveUserIdChanged(const UserId& previously_active_id,
-                             const UserId& active_id) override;
-  void OnUserIdAdded(const UserId& id) override;
   void OnUserIdRemoved(const UserId& id) override;
 
   // WindowManagerWindowTreeFactorySetObserver:
   void OnWindowManagerWindowTreeFactoryReady(
       WindowManagerWindowTreeFactory* factory) override;
 
   const uint32_t id_;
   std::unique_ptr<DisplayBinding> binding_;
   // Set once Init() has been called.
   bool init_called_ = false;
   WindowServer* const window_server_;
   std::unique_ptr<ServerWindow> root_;
   std::unique_ptr<PlatformDisplay> platform_display_;
   std::unique_ptr<FocusController> focus_controller_;
 
   // The last cursor set. Used to track whether we need to change the cursor.
   int32_t last_cursor_;
 
   ServerWindowTracker activation_parents_;
 
   // Set of windows with surfaces that need to be destroyed once the frame
   // draws.
   std::set<ServerWindow*> windows_needing_frame_destruction_;
 
-  WindowManagerStateMap window_manager_state_map_;
+  WindowManagerDisplayRootMap window_manager_display_root_map_;
 
   DISALLOW_COPY_AND_ASSIGN(Display);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_DISPLAY_H_