Adds ability for WindowManager to create display roots

services/ui/ws/window_tree.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 SERVICES_UI_WS_WINDOW_TREE_H_
 #define SERVICES_UI_WS_WINDOW_TREE_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 60 matching lines @@
  public:
   WindowTree(WindowServer* window_server,
              const UserId& user_id,
              ServerWindow* root,
              std::unique_ptr<AccessPolicy> access_policy);
   ~WindowTree() override;
 
   void Init(std::unique_ptr<WindowTreeBinding> binding,
             mojom::WindowTreePtr tree);
 
-  // Called if this WindowTree hosts a WindowManager.
-  void ConfigureWindowManager();
+  // Called if this WindowTree hosts a WindowManager. See mojom for details
+  // on |automatically_create_display_roots|.
+  void ConfigureWindowManager(bool automatically_create_display_roots);
+
+  bool automatically_create_display_roots() const {
+    return automatically_create_display_roots_;
+  }
 
   ClientSpecificId id() const { return id_; }
 
   void set_embedder_intercepts_events() { embedder_intercepts_events_ = true; }
   bool embedder_intercepts_events() const {
     return embedder_intercepts_events_;
   }
 
   const UserId& user_id() const { return user_id_; }
 
@@ skipping 278 matching lines @@
 
   // Calls OnChangeCompleted() on the client.
   void NotifyChangeCompleted(uint32_t change_id,
                              mojom::WindowManagerErrorCode error_code);
 
   // Callback for when WmMoveDragImage completes. This sends off the next
   // queued move under the image if the mouse had further moves while we were
   // waiting for the last move to be acknowledged.
   void OnWmMoveDragImageAck();
 
+  // Called from SetDisplayRoot(), see mojom for details.
+  bool ProcessSetDisplayRoot(int64_t display_id,
+                             const ClientWindowId& client_window_id);
+
   // WindowTree:
   void NewWindow(uint32_t change_id,
                  Id transport_window_id,
                  const base::Optional<
                      std::unordered_map<std::string, std::vector<uint8_t>>>&
                      transport_properties) override;
   void NewTopLevelWindow(
       uint32_t change_id,
       Id transport_window_id,
       const std::unordered_map<std::string, std::vector<uint8_t>>&
@@ skipping 89 matching lines @@
   void CancelWindowMove(Id window_id) override;
 
   // mojom::WindowManagerClient:
   void AddAccelerators(std::vector<mojom::WmAcceleratorPtr> accelerators,
                        const AddAcceleratorsCallback& callback) override;
   void RemoveAccelerator(uint32_t id) override;
   void AddActivationParent(Id transport_window_id) override;
   void RemoveActivationParent(Id transport_window_id) override;
   void ActivateNextWindow() override;
   void SetExtendedHitArea(Id window_id, const gfx::Insets& hit_area) override;
+  void SetDisplayRoot(int64_t display_id,
+                      Id window_id,
+                      const SetDisplayRootCallback& callback) override;
   void WmResponse(uint32_t change_id, bool response) override;
   void WmSetBoundsResponse(uint32_t change_id) override;
   void WmRequestClose(Id transport_window_id) override;
   void WmSetFrameDecorationValues(
       mojom::FrameDecorationValuesPtr values) override;
   void WmSetNonClientCursor(uint32_t window_id,
                             mojom::CursorType cursor_id) override;
   void OnWmCreatedTopLevelWindow(uint32_t change_id,
                                  Id transport_window_id) override;
   void OnAcceleratorAck(
@@ skipping 82 matching lines @@
   bool pointer_watcher_want_moves_ = false;
 
   // True if StartPointerWatcher() was called.
   bool has_pointer_watcher_ = false;
 
   // WindowManager the current event came from.
   WindowManagerState* event_source_wms_ = nullptr;
 
   std::queue<std::unique_ptr<TargetedEvent>> event_queue_;
 
+  // TODO(sky): move all window manager specific state into struct to make it
+  // clear what applies only to the window manager.
   std::unique_ptr<mojo::AssociatedBinding<mojom::WindowManagerClient>>
       window_manager_internal_client_binding_;
   mojom::WindowManager* window_manager_internal_;
   std::unique_ptr<WindowManagerState> window_manager_state_;
+  // See mojom for details.
+  bool automatically_create_display_roots_ = true;
 
   std::unique_ptr<WaitingForTopLevelWindowInfo>
       waiting_for_top_level_window_info_;
   bool embedder_intercepts_events_ = false;
 
   // State kept while we're waiting for the window manager to ack a
   // WmMoveDragImage. Non-null while we're waiting for a response.
   struct DragMoveState;
   std::unique_ptr<DragMoveState> drag_move_state_;
 
   // A weak ptr factory for callbacks from the window manager for when we send
   // a image move. All weak ptrs are invalidated when a drag is completed.
   base::WeakPtrFactory<WindowTree> drag_weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTree);
 };
 
 }  // namespace ws
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_WINDOW_TREE_H_