Moves FrameDecorations from Display to WindowManagerState

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;
 
 // 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 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_; }
 
-  ws::DisplayManager* display_manager() { return display_manager_.get(); }
-  const ws::DisplayManager* display_manager() const {
+  DisplayManager* display_manager() { return display_manager_.get(); }
+  const 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.
@@ skipping 44 matching lines @@
   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;
 
-  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
   // |source| and |client_change_id|. When the window manager replies
   // WindowManagerChangeCompleted() is called to obtain the original source
   // and client supplied change_id that initiated the called.
   uint32_t GenerateWindowManagerChangeId(WindowTree* source,
                                          uint32_t client_change_id);
 
   // Called when a response from the window manager is obtained. Calls to
   // the client that initiated the change with the change id originally
   // supplied by the client.
   void WindowManagerChangeCompleted(uint32_t window_manager_change_id,
                                     bool success);
   void WindowManagerCreatedTopLevelWindow(WindowTree* wm_tree,
                                           uint32_t window_manager_change_id,
                                           const ServerWindow* window);
 
   // Called when we get an unexpected message from the WindowManager.
   // TODO(sky): decide what we want to do here.
   void WindowManagerSentBogusMessage() {}
 
-  // Returns the Display for |display|.
-  mojom::DisplayPtr DisplayToMojomDisplay(Display* display);
-
   // These functions trivially delegate to all WindowTrees, which in
   // term notify their clients.
   void ProcessWindowBoundsChanged(const ServerWindow* window,
                                   const gfx::Rect& old_bounds,
                                   const gfx::Rect& new_bounds);
   void ProcessClientAreaChanged(
       const ServerWindow* window,
       const gfx::Insets& new_client_area,
       const std::vector<gfx::Rect>& new_additional_client_areas);
   void ProcessLostCapture(const ServerWindow* window);
   void ProcessViewportMetricsChanged(Display* display,
                                      const mojom::ViewportMetrics& old_metrics,
                                      const mojom::ViewportMetrics& new_metrics);
   void ProcessWillChangeWindowHierarchy(const ServerWindow* window,
                                         const ServerWindow* new_parent,
                                         const ServerWindow* old_parent);
   void ProcessWindowHierarchyChanged(const ServerWindow* window,
                                      const ServerWindow* new_parent,
                                      const ServerWindow* old_parent);
   void ProcessWindowReorder(const ServerWindow* window,
                             const ServerWindow* relative_window,
                             const mojom::OrderDirection direction);
   void ProcessWindowDeleted(const ServerWindow* window);
   void ProcessWillChangeWindowPredefinedCursor(ServerWindow* window,
                                                int32_t cursor_id);
-  void ProcessFrameDecorationValuesChanged(Display* display);
 
  private:
   friend class Operation;
 
   using WindowTreeMap = std::map<ConnectionSpecificId, scoped_ptr<WindowTree>>;
 
   struct InFlightWindowManagerChange {
     // Identifies the client that initiated the change.
     ConnectionSpecificId connection_id;
 
@@ skipping 21 matching lines @@
 
   // Returns true if the specified connection issued the current operation.
   bool IsOperationSource(ConnectionSpecificId tree_id) const {
     return current_operation_ &&
            current_operation_->source_tree_id() == tree_id;
   }
 
   // Run in response to events which may cause us to change the native cursor.
   void MaybeUpdateNativeCursor(ServerWindow* window);
 
-  // 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(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;
 
@@ skipping 22 matching lines @@
       const std::vector<uint8_t>* new_data) override;
   void OnWindowPredefinedCursorChanged(ServerWindow* window,
                                        int32_t cursor_id) override;
   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_;
 
-  scoped_ptr<ws::DisplayManager> display_manager_;
+  scoped_ptr<DisplayManager> display_manager_;
 
   // Set of WindowTrees.
   WindowTreeMap tree_map_;
 
   // 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_;
 
   // Next id supplied to the window manager.
   uint32_t next_wm_change_id_;
 
-  mojo::BindingSet<mojom::DisplayManager> display_manager_bindings_;
-  // WARNING: only use these once |got_valid_frame_decorations_| is true.
-  // TODO(sky): refactor this out into its own class.
-  mojo::InterfacePtrSet<mojom::DisplayManagerObserver>
-      display_manager_observers_;
-
-  bool got_valid_frame_decorations_;
-
   WindowManagerFactoryRegistry window_manager_factory_registry_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectionManager);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_CONNECTION_MANAGER_H_