Reorder

mojo/services/view_manager/view_manager_connection.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 "mojo/services/view_manager/view_manager_connection.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
 #include "mojo/services/public/cpp/input_events/input_events_type_converters.h"
@@ skipping 152 matching lines @@
          (roots_.count(NodeIdToTransportId(node->id())) > 0) ||
          (new_parent && IsNodeDescendantOfRoots(new_parent)) ||
          (old_parent && IsNodeDescendantOfRoots(old_parent)));
   client()->OnNodeHierarchyChanged(NodeIdToTransportId(node->id()),
                                    NodeIdToTransportId(new_parent_id),
                                    NodeIdToTransportId(old_parent_id),
                                    server_change_id,
                                    NodesToINodes(to_send));
 }
 
+void ViewManagerConnection::ProcessNodeReorder(const Node* node,
+                                               const Node* relative_node,
+                                               OrderDirection direction,
+                                               Id server_change_id,
+                                               bool originated_change) {
+  if (originated_change ||
+      !known_nodes_.count(NodeIdToTransportId(node->id())) ||
+      !known_nodes_.count(NodeIdToTransportId(relative_node->id()))) {
+    return;
+  }
+
+  client()->OnNodeReordered(NodeIdToTransportId(node->id()),
+                            NodeIdToTransportId(relative_node->id()),
+                            direction,
+                            server_change_id);
+}
+
 void ViewManagerConnection::ProcessNodeViewReplaced(
     const Node* node,
     const View* new_view,
     const View* old_view,
     bool originated_change) {
   if (originated_change || !known_nodes_.count(NodeIdToTransportId(node->id())))
     return;
   const Id new_view_id = new_view ?
       ViewIdToTransportId(new_view->id()) : 0;
   const Id old_view_id = old_view ?
@@ skipping 77 matching lines @@
     return true;  // No restriction if there are no roots.
 
   if (!IsNodeDescendantOfRoots(parent) && parent->id().connection_id != id_)
     return false;  // |parent| is not visible to this connection.
 
   // Allow the add if the child is already a descendant of the roots or was
   // created by this connection.
   return (IsNodeDescendantOfRoots(child) || child->id().connection_id == id_);
 }
 
+bool ViewManagerConnection::CanReorderNode(const Node* node,
+                                           const Node* relative_node,
+                                           OrderDirection direction) const {
+  if (!node || !relative_node)
+    return false;
+
+  if (node->id().connection_id != id_)
+    return false;
+
+  const Node* parent = node->GetParent();
+  if (!parent || parent != relative_node->GetParent())
+    return false;
+
+  if (known_nodes_.count(NodeIdToTransportId(parent->id())) == 0)
+    return false;
+
+  std::vector<const Node*> children = parent->GetChildren();
+  const size_t child_i =
+      std::find(children.begin(), children.end(), node) - children.begin();
+  const size_t target_i =
+      std::find(children.begin(), children.end(), relative_node) -
+      children.begin();
+  if ((direction == ORDER_ABOVE && child_i == target_i + 1) ||
+      (direction == ORDER_BELOW && child_i + 1 == target_i)) {
+    return false;
+  }
+
+  return true;
+}
+
 bool ViewManagerConnection::CanDeleteNode(const NodeId& node_id) const {
   return node_id.connection_id == id_;
 }
 
 bool ViewManagerConnection::CanDeleteView(const ViewId& view_id) const {
   return view_id.connection_id == id_;
 }
 
 bool ViewManagerConnection::CanSetView(const Node* node,
                                        const ViewId& view_id) const {
@@ skipping 266 matching lines @@
       success = true;
       RootNodeManager::ScopedChange change(
           this, root_node_manager_,
           RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, false);
       node->GetParent()->Remove(node);
     }
   }
   callback.Run(success);
 }
 
+void ViewManagerConnection::ReorderNode(Id node_id,
+                                        Id relative_node_id,
+                                        OrderDirection direction,
+                                        Id server_change_id,
+                                        const Callback<void(bool)>& callback) {
+  bool success = false;
+  if (server_change_id == root_node_manager_->next_server_change_id()) {
+    Node* node = GetNode(NodeIdFromTransportId(node_id));
+    Node* relative_node = GetNode(NodeIdFromTransportId(relative_node_id));
+    if (CanReorderNode(node, relative_node, direction)) {
+      success = true;
+      RootNodeManager::ScopedChange change(
+          this, root_node_manager_,
+          RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, false);
+      node->GetParent()->Reorder(node, relative_node, direction);
+      root_node_manager_->ProcessNodeReorder(node, relative_node, direction);
+    }
+  }
+  callback.Run(success);
+}
+
 void ViewManagerConnection::GetNodeTree(
     Id node_id,
     const Callback<void(Array<INodePtr>)>& callback) {
   Node* node = GetNode(NodeIdFromTransportId(node_id));
   std::vector<const Node*> nodes;
   if (CanGetNodeTree(node)) {
     GetDescendants(node, &nodes);
     for (size_t i = 0; i < nodes.size(); ++i)
       known_nodes_.insert(NodeIdToTransportId(nodes[i]->id()));
   }
@@ skipping 132 matching lines @@
   client()->OnViewManagerConnectionEstablished(
       id_,
       creator_url_,
       root_node_manager_->next_server_change_id(),
       NodesToINodes(to_send));
 }
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo