Refators display related functionality into own class

components/mus/ws/connection_manager.h

 // Copyright 2014 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_CONNECTION_MANAGER_H_
 #define COMPONENTS_MUS_WS_CONNECTION_MANAGER_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/timer/timer.h"
 #include "components/mus/public/interfaces/display.mojom.h"
 #include "components/mus/public/interfaces/window_manager_factory.mojom.h"
 #include "components/mus/public/interfaces/window_tree.mojom.h"
 #include "components/mus/public/interfaces/window_tree_host.mojom.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/display.h"
+#include "components/mus/ws/display_manager_delegate.h"
 #include "components/mus/ws/ids.h"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/server_window_delegate.h"
 #include "components/mus/ws/server_window_observer.h"
 #include "components/mus/ws/user_id_tracker.h"
 #include "components/mus/ws/window_manager_factory_registry.h"
 #include "mojo/converters/surfaces/custom_surface_converter.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/public/cpp/bindings/interface_ptr_set.h"
 
 namespace mus {
 namespace ws {
 
 class ConnectionManagerDelegate;
+class DisplayManager;
 class ServerWindow;
 class WindowManagerState;
 class WindowTree;
 class WindowTreeBinding;
 
-struct WindowManagerAndDisplay {
-  WindowManagerAndDisplay() : window_manager_state(nullptr), display(nullptr) {}
-
-  WindowManagerState* window_manager_state;
-  Display* display;
-};
-
-struct WindowManagerAndDisplayConst {
-  WindowManagerAndDisplayConst()
-      : window_manager_state(nullptr), display(nullptr) {}
-  const WindowManagerState* window_manager_state;
-  const Display* display;
-};
-
 // ConnectionManager manages the set of connections to the window server (all
 // the WindowTrees) as well as providing the root of the hierarchy.
 //
 // TODO(sky): this class is doing too much. Refactor to make responsibilities
 // clearer.
 class ConnectionManager : public ServerWindowDelegate,
                           public ServerWindowObserver,
-                          public mojom::DisplayManager {
+                          public mojom::DisplayManager,
+                          public DisplayManagerDelegate {
  public:
   ConnectionManager(ConnectionManagerDelegate* delegate,
                     const scoped_refptr<mus::SurfacesState>& surfaces_state);
   ~ConnectionManager() override;
 
   ConnectionManagerDelegate* delegate() { return delegate_; }
 
   UserIdTracker* user_id_tracker() { return &user_id_tracker_; }
 
-  // Adds/removes a Display. ConnectionManager owns the Displays.
-  void AddDisplay(Display* display);
-  void DestroyDisplay(Display* display);
-  std::set<Display*> displays() { return displays_; }
+  ws::DisplayManager* display_manager() { return display_manager_.get(); }
+  const ws::DisplayManager* display_manager() const {
+    return display_manager_.get();
+  }
 
   // Creates a new ServerWindow. The return value is owned by the caller, but
   // must be destroyed before ConnectionManager.
   ServerWindow* CreateServerWindow(
       const WindowId& id,
       const std::map<std::string, std::vector<uint8_t>>& properties);
 
   // Returns the id for the next WindowTree.
   ConnectionSpecificId GetAndAdvanceNextConnectionId();
 
-  // Returns the id for the next root window (both for the root of a Display
-  // as well as the root of WindowManagers).
-  uint16_t GetAndAdvanceNextRootId();
-
   // See description of WindowTree::Embed() for details. This assumes
   // |transport_window_id| is valid.
   WindowTree* EmbedAtWindow(ServerWindow* root,
                             uint32_t policy_bitmask,
                             mojom::WindowTreeClientPtr client);
 
   // Adds |tree_impl_ptr| to the set of known trees. Use DestroyTree() to
   // destroy the tree.
   WindowTree* AddTree(scoped_ptr<WindowTree> tree_impl_ptr,
                       scoped_ptr<WindowTreeBinding> binding,
                       mojom::WindowTreePtr tree_ptr);
   WindowTree* CreateTreeForWindowManager(Display* display,
                                          mojom::WindowManagerFactory* factory,
                                          ServerWindow* root);
   // Invoked when a WindowTree's connection encounters an error.
   void DestroyTree(WindowTree* tree);
 
   // Returns the connection by id.
   WindowTree* GetTreeWithId(ConnectionSpecificId connection_id);
 
   size_t num_trees() const { return tree_map_.size(); }
 
   // Returns the Window identified by |id|.
   ServerWindow* GetWindow(const WindowId& id);
 
   // Schedules a paint for the specified region in the coordinates of |window|.
-  void SchedulePaint(const ServerWindow* window, const gfx::Rect& bounds);
+  void SchedulePaint(ServerWindow* window, const gfx::Rect& bounds);
 
   OperationType current_operation_type() const {
     return current_operation_ ? current_operation_->type()
                               : OperationType::NONE;
   }
 
-  // Invoked when the Display's PlatformDisplay is closed.
-  void OnDisplayClosed();
-
-  // Called when the AcceleratedWidget is available for |display|.
-  void OnDisplayAcceleratedWidgetAvailable(Display* display);
-
   // Invoked when a connection messages a client about the change. This is used
   // to avoid sending ServerChangeIdAdvanced() unnecessarily.
   void OnTreeMessagedClient(ConnectionSpecificId id);
 
   // Returns true if OnTreeMessagedClient() was invoked for id.
   bool DidTreeMessageClient(ConnectionSpecificId id) const;
 
   // Returns the metrics of the viewport where the provided |window| is
   // displayed.
   mojom::ViewportMetricsPtr GetViewportMetricsForWindow(
       const ServerWindow* window);
 
   // Returns the WindowTree that has |id| as a root.
   WindowTree* GetTreeWithRoot(const ServerWindow* window) {
     return const_cast<WindowTree*>(
         const_cast<const ConnectionManager*>(this)->GetTreeWithRoot(window));
   }
   const WindowTree* GetTreeWithRoot(const ServerWindow* window) const;
 
-  // Returns the Display that contains |window|, or null if |window| is not
-  // attached to a display.
-  Display* GetDisplayContaining(const ServerWindow* window);
-  const Display* GetDisplayContaining(const ServerWindow* window) const;
-
-  WindowManagerAndDisplayConst GetWindowManagerAndDisplay(
-      const ServerWindow* window) const;
-  WindowManagerAndDisplay GetWindowManagerAndDisplay(
-      const ServerWindow* window);
-
-  Display* GetActiveDisplay();
-
-  bool has_displays() const { return !displays_.empty(); }
-
   void AddDisplayManagerBinding(
       mojo::InterfaceRequest<mojom::DisplayManager> request);
 
   void OnFirstWindowManagerFactorySet();
 
   WindowManagerFactoryRegistry* window_manager_factory_registry() {
     return &window_manager_factory_registry_;
   }
 
   // Returns a change id for the window manager that is associated with
@@ skipping 88 matching lines @@
 
   // Calls OnDisplays() on |observer|.
   void CallOnDisplays(mojom::DisplayManagerObserver* observer);
 
   // Calls observer->OnDisplaysChanged() with the display for |display|.
   void CallOnDisplayChanged(mojom::DisplayManagerObserver* observer,
                             Display* display);
 
   // Overridden from ServerWindowDelegate:
   mus::SurfacesState* GetSurfacesState() override;
-  void OnScheduleWindowPaint(const ServerWindow* window) override;
+  void OnScheduleWindowPaint(ServerWindow* window) override;
   const ServerWindow* GetRootWindow(const ServerWindow* window) const override;
   void ScheduleSurfaceDestruction(ServerWindow* window) override;
   ServerWindow* FindWindowForSurface(
       const ServerWindow* ancestor,
       mojom::SurfaceType surface_type,
       const ClientWindowId& client_window_id) override;
 
   // Overridden from ServerWindowObserver:
   void OnWindowDestroyed(ServerWindow* window) override;
   void OnWillChangeWindowHierarchy(ServerWindow* window,
@@ skipping 22 matching lines @@
   void OnWindowTextInputStateChanged(ServerWindow* window,
                                      const ui::TextInputState& state) override;
   void OnTransientWindowAdded(ServerWindow* window,
                               ServerWindow* transient_child) override;
   void OnTransientWindowRemoved(ServerWindow* window,
                                 ServerWindow* transient_child) override;
 
   // Overriden from mojom::DisplayManager:
   void AddObserver(mojom::DisplayManagerObserverPtr observer) override;
 
+  // DisplayManagerDelegate:
+  void OnWillDestroyDisplay(Display* display) override;
+  void OnFirstDisplayReady() override;
+  void OnNoMoreDisplays() override;
+
   UserIdTracker user_id_tracker_;
 
   ConnectionManagerDelegate* delegate_;
 
   // State for rendering into a Surface.
   scoped_refptr<mus::SurfacesState> surfaces_state_;
 
   // ID to use for next WindowTree.
   ConnectionSpecificId next_connection_id_;
 
-  // ID to use for next root node.
-  uint16_t next_root_id_;
+  scoped_ptr<ws::DisplayManager> display_manager_;
 
   // Set of WindowTrees.
   WindowTreeMap tree_map_;
 
-  // Displays are initially added to |pending_displays_|. When the display is
-  // initialized it is moved to |displays_|. ConnectionManager owns the
-  // Displays.
-  std::set<Display*> pending_displays_;
-  std::set<Display*> displays_;
-
   // If non-null then we're processing a client operation. The Operation is
   // not owned by us (it's created on the stack by WindowTree).
   Operation* current_operation_;
 
   bool in_destructor_;
 
   // Maps from window manager change id to the client that initiated the
   // request.
   InFlightWindowManagerChangeMap in_flight_wm_change_map_;
 
@@ skipping 10 matching lines @@
 
   WindowManagerFactoryRegistry window_manager_factory_registry_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectionManager);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_CONNECTION_MANAGER_H_