aura-mus: Implement stacking in DesktopWindowTreeHostMus.

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 806 matching lines @@
   // If the client created this window, then do not route it through the WM.
   if (window->id().client_id == id_)
     return false;
 
   // If the client did not create the window, then it must be the root of the
   // client. If not, that means the client should not know about this window,
   // and so do not route the request to the WM.
   if (roots_.count(window) == 0)
     return false;
 
-  // The WindowManager is attached to the root of the Display, if there isn't a
-  // WindowManager attached no need to route to it.
-  const WindowManagerDisplayRoot* display_root =
-      GetWindowManagerDisplayRoot(window);
-  if (!display_root)
-    return false;
-
-  // Route to the windowmanager if the windowmanager created the window.
-  return display_root->window_manager_state()->window_tree()->id() ==
-         window->id().client_id;
+  return IsWindowCreatedByWindowManager(window);
 }
 
 void WindowTree::ProcessCaptureChanged(const ServerWindow* new_capture,
                                        const ServerWindow* old_capture,
                                        bool originated_change) {
   ClientWindowId new_capture_window_client_id;
   ClientWindowId old_capture_window_client_id;
   const bool new_capture_window_known =
       IsWindowKnown(new_capture, &new_capture_window_client_id);
   const bool old_capture_window_known =
@@ skipping 751 matching lines @@
     // The window isn't parented. There's nothing to do.
     DVLOG(1) << "DeactivateWindow failed (window unparented)";
     return;
   }
 
   WindowTree* wm_tree = display_root->window_manager_state()->window_tree();
   wm_tree->window_manager_internal_->WmDeactivateWindow(
       wm_tree->ClientWindowIdForWindow(window).id);
 }
 
+void WindowTree::StackAtTop(uint32_t change_id, Id window_id) {
+  ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
+  if (!window) {
+    DVLOG(1) << "StackAtTop failed (invalid id)";
+    client()->OnChangeCompleted(change_id, false);
+    return;
+  }
+
+  if (!access_policy_->CanStackAtTop(window)) {
+    DVLOG(1) << "StackAtTop failed (access denied)";
+    client()->OnChangeCompleted(change_id, false);
+    return;
+  }
+
+  ServerWindow* parent = window->parent();
+  if (!parent) {
+    DVLOG(1) << "StackAtTop failed (window unparented)";
+    client()->OnChangeCompleted(change_id, false);
+    return;
+  }
+
+  DCHECK(!parent->children().empty());
+  if (parent->children().back() == window) {
+    // Ignore this call; the client didn't know they were already at the top.
+    DVLOG(3) << "StackAtTop ignored (already at top)";
+    client()->OnChangeCompleted(change_id, true);
+    return;
+  }
+
+  ServerWindow* relative_window = parent->children().back();
+  Operation op(this, window_server_, OperationType::REORDER_WINDOW);
+  window->Reorder(relative_window, mojom::OrderDirection::ABOVE);
+  window_server_->ProcessWindowReorder(window, relative_window,
+                                       mojom::OrderDirection::ABOVE);
+
+  client()->OnChangeCompleted(change_id, true);
+}
+
 void WindowTree::GetWindowManagerClient(
     mojo::AssociatedInterfaceRequest<mojom::WindowManagerClient> internal) {
   if (!access_policy_->CanSetWindowManager() || !window_manager_internal_ ||
       window_manager_internal_client_binding_) {
     return;
   }
   window_manager_internal_client_binding_.reset(
       new mojo::AssociatedBinding<mojom::WindowManagerClient>(
           this, std::move(internal)));
 }
@@ skipping 311 matching lines @@
     const ServerWindow* window) const {
   return IsWindowKnown(window);
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
+bool WindowTree::IsWindowCreatedByWindowManager(
+    const ServerWindow* window) const {
+  // The WindowManager is attached to the root of the Display, if there isn't a
+  // WindowManager attached, the window manager didn't create this window.
+  const WindowManagerDisplayRoot* display_root =
+      GetWindowManagerDisplayRoot(window);
+  if (!display_root)
+    return false;
+
+  return display_root->window_manager_state()->window_tree()->id() ==
+         window->id().client_id;
+}
+
 void WindowTree::OnDragCompleted(bool success, uint32_t action_taken) {
   DCHECK(window_server_->in_drag_loop());
 
   if (window_server_->GetCurrentDragLoopInitiator() != this)
     return;
 
   uint32_t change_id = window_server_->GetCurrentDragLoopChangeId();
   ServerWindow* window = window_server_->GetCurrentDragLoopWindow();
   WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(window);
   if (!display_root)
@@ skipping 81 matching lines @@
   client()->OnCompleteDrop(client_window_id.id, event_flags, cursor_offset,
                            effect_bitmask, callback);
 }
 
 void WindowTree::PerformOnDragDropDone() {
   client()->OnDragDropDone();
 }
 
 }  // namespace ws
 }  // namespace ui