Adds ability for WindowManager to create display roots

services/ui/ws/window_tree.cc

 // 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.
 
 #include "services/ui/ws/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 83 matching lines @@
     roots_.insert(root);
   access_policy_->Init(id_, this);
 }
 
 WindowTree::~WindowTree() {
   DestroyWindows();
 
   // We alert the WindowManagerState that we're destroying this state here
   // because WindowManagerState would attempt to use things that wouldn't have
   // been cleaned up by OnWindowDestroyingTreeImpl().
-  if (window_manager_state_)
+  if (window_manager_state_) {
     window_manager_state_->OnWillDestroyTree(this);
+    window_manager_state_.reset();
+  }
 }
 
 void WindowTree::Init(std::unique_ptr<WindowTreeBinding> binding,
                       mojom::WindowTreePtr tree) {
   DCHECK(!binding_);
   binding_ = std::move(binding);
 
   if (roots_.empty())
     return;
 
@@ skipping 11 matching lines @@
   ClientWindowId focused_window_id;
   if (focused_window)
     IsWindowKnown(focused_window, &focused_window_id);
 
   const bool drawn = root->parent() && root->parent()->IsDrawn();
   client()->OnEmbed(id_, WindowToWindowData(to_send.front()), std::move(tree),
                     display_id, focused_window_id.id, drawn,
                     root->frame_sink_id(), root->current_local_surface_id());
 }
 
-void WindowTree::ConfigureWindowManager() {
+void WindowTree::ConfigureWindowManager(
+    bool automatically_create_display_roots) {
   // ConfigureWindowManager() should be called early on, before anything
   // else. |waiting_for_top_level_window_info_| must be null as if
   // |waiting_for_top_level_window_info_| is non-null it means we're about to
   // create an associated interface, which doesn't work with pause/resume.
   // TODO(sky): DCHECK temporary until 626869 is sorted out.
   DCHECK(!waiting_for_top_level_window_info_);
   DCHECK(!window_manager_internal_);
+  automatically_create_display_roots_ = automatically_create_display_roots;
   window_manager_internal_ = binding_->GetWindowManager();
   window_manager_internal_->OnConnect(id_);
   window_manager_state_ = base::MakeUnique<WindowManagerState>(this);
 }
 
 const ServerWindow* WindowTree::GetWindow(const WindowId& id) const {
   if (id_ == id.client_id) {
     auto iter = created_window_map_.find(id);
     return iter == created_window_map_.end() ? nullptr : iter->second;
   }
@@ skipping 42 matching lines @@
 }
 
 void WindowTree::PrepareForWindowServerShutdown() {
   window_manager_internal_client_binding_.reset();
   binding_->ResetClientForShutdown();
   if (window_manager_internal_)
     window_manager_internal_ = binding_->GetWindowManager();
 }
 
 void WindowTree::AddRootForWindowManager(const ServerWindow* root) {
+  if (!automatically_create_display_roots_)
+    return;
+
+  DCHECK(automatically_create_display_roots_);
   DCHECK(window_manager_internal_);
   const ClientWindowId client_window_id(WindowIdToTransportId(root->id()));
   DCHECK_EQ(0u, client_id_to_window_id_map_.count(client_window_id));
   client_id_to_window_id_map_[client_window_id] = root->id();
   window_id_to_client_id_map_[root->id()] = client_window_id;
   roots_.insert(root);
 
   Display* ws_display = GetDisplay(root);
   DCHECK(ws_display);
 
@@ skipping 31 matching lines @@
 void WindowTree::OnWmMoveDragImageAck() {
   if (drag_move_state_->has_queued_drag_window_move) {
     gfx::Point queued_location = drag_move_state_->queued_cursor_location;
     drag_move_state_.reset();
     OnDragMoved(queued_location);
   } else {
     drag_move_state_.reset();
   }
 }
 
+bool WindowTree::ProcessSetDisplayRoot(int64_t display_id,
+                                       const ClientWindowId& client_window_id) {
+  DCHECK(window_manager_state_);  // Only called for window manager.
+  Display* display =
+      window_server_->display_manager()->GetDisplayById(display_id);
+  if (!display) {
+    DVLOG(1) << "SetDisplayRoot called with unknown display " << display_id;
+    return false;
+  }
+
+  if (automatically_create_display_roots_) {
+    DVLOG(1) << "SetDisplayRoot is only applicable when "
+             << "automatically_create_display_roots is false";
+    return false;
+  }
+
+  ServerWindow* window = GetWindowByClientId(client_window_id);
+  // The window must not have a parent.
+  if (!window || window->parent()) {
+    DVLOG(1) << "SetDisplayRoot called with invalid window id "
+             << client_window_id.id;
+    return false;
+  }
+
+  WindowManagerDisplayRoot* display_root =
+      display->GetWindowManagerDisplayRootForUser(
+          window_manager_state_->user_id());
+  DCHECK(display_root);
+  if (!display_root->root()->children().empty()) {
+    DVLOG(1) << "SetDisplayRoot called more than once";
+    return false;
+  }
+
+  if (base::ContainsValue(roots_, window)) {
+    DVLOG(1) << "SetDisplayRoot called with existing root";
+    return false;
+  }
+
+  // NOTE: this doesn't resize the window in anyway. We assume the client takes
+  // care of any modifications it needs to do.
+  roots_.insert(window);
+  Operation op(this, window_server_, OperationType::ADD_WINDOW);
+  display_root->root()->Add(window);
+  return true;
+}
+
 bool WindowTree::SetCapture(const ClientWindowId& client_window_id) {
   ServerWindow* window = GetWindowByClientId(client_window_id);
   WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(window);
   ServerWindow* current_capture_window =
       display_root ? display_root->window_manager_state()->capture_window()
                    : nullptr;
   if (window && window->IsDrawn() && display_root &&
       display_root->window_manager_state()->IsActive() &&
       access_policy_->CanSetCapture(window) &&
       (!current_capture_window ||
@@ skipping 321 matching lines @@
   else
     DCHECK_EQ(0u, event_ack_id_);
   // TODO(moshayedi): crbug.com/617167. Don't clone even once we map
   // mojom::Event directly to ui::Event.
   window_manager_internal_->OnAccelerator(event_ack_id_, accelerator_id,
                                           ui::Event::Clone(event));
 }
 
 void WindowTree::OnDisplayDestroying(int64_t display_id) {
   DCHECK(window_manager_internal_);
-  window_manager_internal_->WmDisplayRemoved(display_id);
+  if (automatically_create_display_roots_)
+    window_manager_internal_->WmDisplayRemoved(display_id);
+  // For the else case the client should detect removal directly.
 }
 
 void WindowTree::ClientJankinessChanged(WindowTree* tree) {
   tree->janky_ = !tree->janky_;
   // Don't inform the client if it is the source of jank (which generally only
   // happens while debugging).
   if (window_manager_internal_ && tree != this) {
     window_manager_internal_->WmClientJankinessChanged(
         tree->id(), tree->janky());
   }
@@ skipping 427 matching lines @@
 
   const ServerWindow::Windows& children = window->children();
   for (ServerWindow* child : children)
     RemoveFromKnown(child, local_windows);
 }
 
 void WindowTree::RemoveRoot(ServerWindow* window, RemoveRootReason reason) {
   DCHECK(roots_.count(window) > 0);
   roots_.erase(window);
 
+  if (window->id().client_id == id_) {
+    // This cllient created the window. If this client is the window manager and
+    // display roots are manually created, then |window| is a display root and
+    // needs be cleaned.
+    if (window_manager_state_ && !automatically_create_display_roots_) {
+      // The window manager is asking to delete the root it created.
+      window_manager_state_->DeleteWindowManagerDisplayRoot(window->parent());
+      DeleteWindowImpl(this, window);
+    }
+    return;
+  }
+
   const ClientWindowId client_window_id(ClientWindowIdForWindow(window));
 
-  // No need to do anything if we created the window.
-  if (window->id().client_id == id_)
-    return;
-
   if (reason == RemoveRootReason::EMBED) {
     client()->OnUnembed(client_window_id.id);
     client()->OnWindowDeleted(client_window_id.id);
     window_server_->OnTreeMessagedClient(id_);
   }
 
   // This client no longer knows about the window. Unparent any windows that
   // were parented to windows in the root.
   std::vector<ServerWindow*> local_windows;
   RemoveFromKnown(window, &local_windows);
@@ skipping 971 matching lines @@
     DVLOG(1) << "SetExtendedHitArea supplied unknown window";
     return;
   }
   if (window->id().client_id != id_) {
     DVLOG(1) << "SetExtendedHitArea supplied window that client does not own";
     return;
   }
   window->set_extended_hit_test_region(hit_area);
 }
 
+void WindowTree::SetDisplayRoot(int64_t display_id,
+                                Id window_id,
+                                const SetDisplayRootCallback& callback) {
+  callback.Run(ProcessSetDisplayRoot(display_id, ClientWindowId(window_id)));
+}
+
 void WindowTree::WmResponse(uint32_t change_id, bool response) {
   if (window_server_->in_move_loop() &&
       window_server_->GetCurrentMoveLoopChangeId() == change_id) {
     ServerWindow* window = window_server_->GetCurrentMoveLoopWindow();
 
     if (window->id().client_id != id_) {
       window_server_->WindowManagerSentBogusMessage();
       window = nullptr;
     } else {
       WindowManagerDisplayRoot* display_root =
@@ skipping 227 matching lines @@
   client()->OnCompleteDrop(client_window_id.id, event_flags, cursor_offset,
                            effect_bitmask, callback);
 }
 
 void WindowTree::PerformOnDragDropDone() {
   client()->OnDragDropDone();
 }
 
 }  // namespace ws
 }  // namespace ui