Moves FrameDecorations from Display to 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 56 matching lines @@
           mojo::Connector* connector,
           const scoped_refptr<GpuState>& gpu_state,
           const scoped_refptr<SurfacesState>& surfaces_state);
   ~Display() override;
 
   // Initializes state that depends on the existence of a Display.
   void Init(scoped_ptr<DisplayBinding> binding);
 
   uint32_t id() const { return id_; }
 
-  // TODO(sky): move to WMM.
-  void SetFrameDecorationValues(mojom::FrameDecorationValuesPtr values);
-  const mojom::FrameDecorationValues& frame_decoration_values() const {
-    return *frame_decoration_values_;
-  }
+  DisplayManager* display_manager();
+  const DisplayManager* display_manager() const;
+
+  // Returns a mojom::Display for the specified display. WindowManager specific
+  // values are not set. In general you should use
+  // WindowManagerState::ToMojomDisplay().
+  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);
 
   // Returns the metrics for this viewport.
   const mojom::ViewportMetrics& GetViewportMetrics() const;
 
   mojom::Rotation GetRotation() const;
 
   ConnectionManager* connection_manager() { return connection_manager_; }
 
   EventDispatcher* event_dispatcher() { return &event_dispatcher_; }
 
   // 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(); }
 
   ServerWindow* GetRootWithId(const WindowId& id);
 
   WindowManagerState* GetWindowManagerStateWithRoot(const ServerWindow* window);
   // TODO(sky): this is wrong, plumb through user_id.
   WindowManagerState* GetFirstWindowManagerState();
-  WindowManagerState* GetWindowManagerStateForUser(const UserId& user_id);
+  WindowManagerState* GetWindowManagerStateForUser(const UserId& user_id) {
+    return const_cast<WindowManagerState*>(
+        const_cast<const Display*>(this)->GetWindowManagerStateForUser(
+            user_id));
+  }
+  const WindowManagerState* GetWindowManagerStateForUser(
+      const UserId& user_id) const;
   size_t num_window_manger_states() const {
     return window_manager_state_map_.size();
   }
 
   void SetCapture(ServerWindow* window, bool in_nonclient_area);
 
   void SetFocusedWindow(ServerWindow* window);
   ServerWindow* GetFocusedWindow();
   void DestroyFocusController();
   FocusController* focus_controller() { return focus_controller_.get(); }
@@ skipping 50 matching lines @@
     QueuedEvent();
     ~QueuedEvent();
 
     scoped_ptr<ui::Event> event;
     scoped_ptr<ProcessedEventTarget> processed_target;
   };
 
   // Inits the necessary state once the display is ready.
   void InitWindowManagersIfNecessary();
 
-  DisplayManager* display_manager();
-  const DisplayManager* display_manager() const;
-
   void OnEventAckTimeout();
 
   // Schedules an event to be processed later.
   void QueueEvent(const ui::Event& event,
                   scoped_ptr<ProcessedEventTarget> processed_event_target);
 
   // Processes the next valid event in |event_queue_|. If the event has already
   // been processed it is dispatched, otherwise the event is passed to the
   // EventDispatcher for processing.
   void ProcessNextEventFromQueue();
@@ skipping 73 matching lines @@
 
   // Set of windows with surfaces that need to be destroyed once the frame
   // draws.
   std::set<ServerWindow*> windows_needing_frame_destruction_;
 
   std::queue<scoped_ptr<QueuedEvent>> event_queue_;
   base::OneShotTimer event_ack_timer_;
 
   WindowManagerStateMap window_manager_state_map_;
 
-  mojom::FrameDecorationValuesPtr frame_decoration_values_;
-
   DISALLOW_COPY_AND_ASSIGN(Display);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_DISPLAY_H_