Fixes bug in handling restacking because of transients

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 841 matching lines @@
 }
 
 WindowId WindowTree::GenerateNewWindowId() {
   // TODO(sky): deal with wrapping and uniqueness.
   return WindowId(id_, next_window_id_++);
 }
 
 bool WindowTree::CanReorderWindow(const ServerWindow* window,
                                   const ServerWindow* relative_window,
                                   mojom::OrderDirection direction) const {
-  if (!window || !relative_window)
+  if (!window) {
+    DVLOG(1) << "reorder failing: invalid window";
     return false;
+  }
+  if (!relative_window) {
+    DVLOG(1) << "reorder failing: invalid relative window";
+    return false;
+  }
 
-  if (!window->parent() || window->parent() != relative_window->parent())
+  if (!window->parent()) {
+    DVLOG(1) << "reorder failing: no parent";
     return false;
+  }
 
-  if (!access_policy_->CanReorderWindow(window, relative_window, direction))
+  if (window->parent() != relative_window->parent()) {
+    DVLOG(1) << "reorder failing: parents differ";
     return false;
+  }
+
+  if (!access_policy_->CanReorderWindow(window, relative_window, direction)) {
+    DVLOG(1) << "reorder failing: access policy denied";
+    return false;
+  }
 
   const ServerWindow::Windows& children = window->parent()->children();
   const size_t child_i =
       std::find(children.begin(), children.end(), window) - children.begin();
   const size_t target_i =
       std::find(children.begin(), children.end(), relative_window) -
       children.begin();
   if ((direction == mojom::OrderDirection::ABOVE && child_i == target_i + 1) ||
       (direction == mojom::OrderDirection::BELOW && child_i + 1 == target_i)) {
+    DVLOG(1) << "reorder failing: already in position";
     return false;
   }
 
   return true;
 }
 
 bool WindowTree::DeleteWindowImpl(WindowTree* source, ServerWindow* window) {
   DCHECK(window);
   DCHECK_EQ(window->id().client_id, id_);
   Operation op(source, window_server_, OperationType::DELETE_WINDOW);
@@ skipping 356 matching lines @@
 }
 
 void WindowTree::ReorderWindow(uint32_t change_id,
                                Id window_id,
                                Id relative_window_id,
                                mojom::OrderDirection direction) {
   bool success = false;
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   ServerWindow* relative_window =
       GetWindowByClientId(ClientWindowId(relative_window_id));
+  DVLOG(3) << "reorder client=" << id_ << " client window_id=" << window_id
+           << " global window_id="
+           << (window ? WindowIdToTransportId(window->id()) : 0)
+           << " relative client window_id=" << relative_window_id
+           << " relative global window_id="
+           << (relative_window ? WindowIdToTransportId(relative_window->id())
+                               : 0);
   if (CanReorderWindow(window, relative_window, direction)) {
     success = true;
     Operation op(this, window_server_, OperationType::REORDER_WINDOW);
     window->Reorder(relative_window, direction);
     window_server_->ProcessWindowReorder(window, relative_window, direction);
   }
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::GetWindowTree(
@@ skipping 680 matching lines @@
   client()->OnCompleteDrop(client_window_id.id, event_flags, cursor_offset,
                            effect_bitmask, callback);
 }
 
 void WindowTree::PerformOnDragDropDone() {
   client()->OnDragDropDone();
 }
 
 }  // namespace ws
 }  // namespace ui