Nukes change_ids from view manager

mojo/services/view_manager/view_manager_service_impl.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_service_impl.h"
 
 #include "base/bind.h"
 #include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
 #include "mojo/services/public/cpp/input_events/input_events_type_converters.h"
 #include "mojo/services/view_manager/node.h"
@@ skipping 42 matching lines @@
 
 ViewManagerServiceImpl::~ViewManagerServiceImpl() {
   // Delete any views we created.
   while (!view_map_.empty()) {
     bool result = DeleteViewImpl(this, view_map_.begin()->second->id());
     DCHECK(result);
   }
 
   // Ditto the nodes.
   if (!node_map_.empty()) {
-    RootNodeManager::ScopedChange change(
-        this, root_node_manager_,
-        RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, true);
+    RootNodeManager::ScopedChange change(this, root_node_manager_, true);
     while (!node_map_.empty())
       delete node_map_.begin()->second;
   }
 
   root_node_manager_->RemoveConnection(this);
 }
 
 const Node* ViewManagerServiceImpl::GetNode(const NodeId& id) const {
   if (id_ == id.connection_id) {
     NodeMap::const_iterator i = node_map_.find(id.node_id);
@@ skipping 32 matching lines @@
     client()->OnNodeBoundsChanged(node_id,
                                   Rect::From(old_bounds),
                                   Rect::From(new_bounds));
   }
 }
 
 void ViewManagerServiceImpl::ProcessNodeHierarchyChanged(
     const Node* node,
     const Node* new_parent,
     const Node* old_parent,
-    Id server_change_id,
     bool originated_change) {
   if (known_nodes_.count(NodeIdToTransportId(node->id())) > 0) {
     if (originated_change)
       return;
     if (node->id().connection_id != id_ && !IsNodeDescendantOfRoots(node)) {
       // Node was a descendant of roots and is no longer, treat it as though the
       // node was deleted.
       RemoveFromKnown(node, NULL);
-      client()->OnNodeDeleted(NodeIdToTransportId(node->id()),
-                              server_change_id);
+      client()->OnNodeDeleted(NodeIdToTransportId(node->id()));
       root_node_manager_->OnConnectionMessagedClient(id_);
       return;
     }
   }
 
   if (originated_change || root_node_manager_->is_processing_delete_node())
     return;
   std::vector<const Node*> to_send;
   if (!ShouldNotifyOnHierarchyChange(node, &new_parent, &old_parent,
                                      &to_send)) {
-    if (root_node_manager_->IsProcessingChange()) {
-      client()->OnServerChangeIdAdvanced(
-          root_node_manager_->next_server_change_id() + 1);
-    }
     return;
   }
   const NodeId new_parent_id(new_parent ? new_parent->id() : NodeId());
   const NodeId old_parent_id(old_parent ? old_parent->id() : NodeId());
   DCHECK((node->id().connection_id == id_) ||
          (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,
                                    NodesToNodeDatas(to_send));
 }
 
 void ViewManagerServiceImpl::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);
+                            direction);
 }
 
 void ViewManagerServiceImpl::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 ?
       ViewIdToTransportId(old_view->id()) : 0;
   client()->OnNodeViewReplaced(NodeIdToTransportId(node->id()),
                                new_view_id, old_view_id);
 }
 
 void ViewManagerServiceImpl::ProcessNodeDeleted(const NodeId& node,
-                                                Id server_change_id,
                                                 bool originated_change) {
   node_map_.erase(node.node_id);
 
   const bool in_known = known_nodes_.erase(NodeIdToTransportId(node)) > 0;
   const bool in_roots = roots_.erase(NodeIdToTransportId(node)) > 0;
 
   if (in_roots && roots_.empty())
     roots_.insert(NodeIdToTransportId(InvalidNodeId()));
 
   if (originated_change)
     return;
 
   if (in_known) {
-    client()->OnNodeDeleted(NodeIdToTransportId(node), server_change_id);
+    client()->OnNodeDeleted(NodeIdToTransportId(node));
     root_node_manager_->OnConnectionMessagedClient(id_);
   } else if (root_node_manager_->IsProcessingChange() &&
              !root_node_manager_->DidConnectionMessageClient(id_)) {
-    client()->OnServerChangeIdAdvanced(
-        root_node_manager_->next_server_change_id() + 1);
     root_node_manager_->OnConnectionMessagedClient(id_);
   }
 }
 
 void ViewManagerServiceImpl::ProcessViewDeleted(const ViewId& view,
                                                 bool originated_change) {
   if (originated_change)
     return;
   client()->OnViewDeleted(ViewIdToTransportId(view));
 }
@@ skipping 133 matching lines @@
        roots_.find(NodeIdToTransportId(node->id())) != roots_.end()) &&
       node->IsVisible() != visibile;
 }
 
 bool ViewManagerServiceImpl::DeleteNodeImpl(ViewManagerServiceImpl* source,
                                             const NodeId& node_id) {
   DCHECK_EQ(node_id.connection_id, id_);
   Node* node = GetNode(node_id);
   if (!node)
     return false;
-  RootNodeManager::ScopedChange change(
-      source, root_node_manager_,
-      RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, true);
+  RootNodeManager::ScopedChange change(source, root_node_manager_, true);
   delete node;
   return true;
 }
 
 bool ViewManagerServiceImpl::DeleteViewImpl(ViewManagerServiceImpl* source,
                                             const ViewId& view_id) {
   DCHECK_EQ(view_id.connection_id, id_);
   View* view = GetView(view_id);
   if (!view)
     return false;
-  RootNodeManager::ScopedChange change(
-      source, root_node_manager_,
-      RootNodeManager::CHANGE_TYPE_DONT_ADVANCE_SERVER_CHANGE_ID, false);
+  RootNodeManager::ScopedChange change(source, root_node_manager_, false);
   if (view->node())
     view->node()->SetView(NULL);
   view_map_.erase(view_id.view_id);
   // Make a copy of |view_id| as once we delete view |view_id| may no longer be
   // valid.
   const ViewId view_id_copy(view_id);
   delete view;
   root_node_manager_->ProcessViewDeleted(view_id_copy);
   return true;
 }
 
 bool ViewManagerServiceImpl::SetViewImpl(Node* node, const ViewId& view_id) {
   DCHECK(node);  // CanSetView() should have verified node exists.
   View* view = GetView(view_id);
-  RootNodeManager::ScopedChange change(
-      this, root_node_manager_,
-      RootNodeManager::CHANGE_TYPE_DONT_ADVANCE_SERVER_CHANGE_ID, false);
+  RootNodeManager::ScopedChange change(this, root_node_manager_, false);
   node->SetView(view);
   return true;
 }
 
 void ViewManagerServiceImpl::GetUnknownNodesFrom(
     const Node* node,
     std::vector<const Node*>* nodes) {
   const Id transport_id = NodeIdToTransportId(node->id());
   if (known_nodes_.count(transport_id) == 1)
     return;
@@ skipping 43 matching lines @@
   CHECK(roots_.count(transport_node_id) > 0);
 
   roots_.erase(transport_node_id);
   if (roots_.empty())
     roots_.insert(NodeIdToTransportId(InvalidNodeId()));
 
   // No need to do anything if we created the node.
   if (node_id.connection_id == id_)
     return;
 
-  client()->OnNodeDeleted(transport_node_id,
-                          root_node_manager_->next_server_change_id());
+  client()->OnNodeDeleted(transport_node_id);
   root_node_manager_->OnConnectionMessagedClient(id_);
 
   // This connection no longer knows about the node. Unparent any nodes that
   // were parented to nodes in the root.
   std::vector<Node*> local_nodes;
   RemoveFromKnown(GetNode(node_id), &local_nodes);
   for (size_t i = 0; i < local_nodes.size(); ++i)
     local_nodes[i]->GetParent()->Remove(local_nodes[i]);
 }
 
@@ skipping 93 matching lines @@
     error_code = ERROR_CODE_VALUE_IN_USE;
   } else {
     node_map_[node_id.node_id] = new Node(root_node_manager_, node_id);
     known_nodes_.insert(transport_node_id);
   }
   callback.Run(error_code);
 }
 
 void ViewManagerServiceImpl::DeleteNode(
     Id transport_node_id,
-    Id server_change_id,
     const Callback<void(bool)>& callback) {
   const NodeId node_id(NodeIdFromTransportId(transport_node_id));
   bool success = false;
-  if (server_change_id == root_node_manager_->next_server_change_id() &&
-      CanDeleteNode(node_id)) {
+  if (CanDeleteNode(node_id)) {
     ViewManagerServiceImpl* connection = root_node_manager_->GetConnection(
         node_id.connection_id);
     success = connection && connection->DeleteNodeImpl(this, node_id);
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::AddNode(
     Id parent_id,
     Id child_id,
-    Id server_change_id,
     const Callback<void(bool)>& callback) {
   bool success = false;
-  if (server_change_id == root_node_manager_->next_server_change_id()) {
-    Node* parent = GetNode(NodeIdFromTransportId(parent_id));
-    Node* child = GetNode(NodeIdFromTransportId(child_id));
-    if (CanAddNode(parent, child)) {
-      success = true;
-      RootNodeManager::ScopedChange change(
-          this, root_node_manager_,
-          RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, false);
-      parent->Add(child);
-    }
+  Node* parent = GetNode(NodeIdFromTransportId(parent_id));
+  Node* child = GetNode(NodeIdFromTransportId(child_id));
+  if (CanAddNode(parent, child)) {
+    success = true;
+    RootNodeManager::ScopedChange change(this, root_node_manager_, false);
+    parent->Add(child);
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::RemoveNodeFromParent(
     Id node_id,
-    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));
-    if (CanRemoveNodeFromParent(node)) {
-      success = true;
-      RootNodeManager::ScopedChange change(
-          this, root_node_manager_,
-          RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, false);
-      node->GetParent()->Remove(node);
-    }
+  Node* node = GetNode(NodeIdFromTransportId(node_id));
+  if (CanRemoveNodeFromParent(node)) {
+    success = true;
+    RootNodeManager::ScopedChange change(this, root_node_manager_, false);
+    node->GetParent()->Remove(node);
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::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);
-    }
+  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_, false);
+    node->GetParent()->Reorder(node, relative_node, direction);
+    root_node_manager_->ProcessNodeReorder(node, relative_node, direction);
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::GetNodeTree(
     Id node_id,
     const Callback<void(Array<NodeDataPtr>)>& callback) {
   Node* node = GetNode(NodeIdFromTransportId(node_id));
   std::vector<const Node*> nodes;
   if (CanGetNodeTree(node)) {
@@ skipping 80 matching lines @@
     callback.Run(false);
     return;
   }
 
   Node* node = GetNode(NodeIdFromTransportId(node_id));
   if (!node) {
     callback.Run(false);
     return;
   }
 
-  RootNodeManager::ScopedChange change(
-      this, root_node_manager_,
-      RootNodeManager::CHANGE_TYPE_DONT_ADVANCE_SERVER_CHANGE_ID, false);
+  RootNodeManager::ScopedChange change(this, root_node_manager_, false);
   gfx::Rect old_bounds = node->window()->bounds();
   node->window()->SetBounds(bounds.To<gfx::Rect>());
   callback.Run(true);
 }
 
 void ViewManagerServiceImpl::SetNodeVisibility(
     Id transport_node_id,
     bool visible,
     const Callback<void(bool)>& callback) {
   const NodeId node_id(NodeIdFromTransportId(transport_node_id));
@@ skipping 14 matching lines @@
   if (success) {
     // Only allow a node to be the root for one connection.
     const NodeId node_id(NodeIdFromTransportId(transport_node_id));
     ViewManagerServiceImpl* connection_by_url =
         root_node_manager_->GetConnectionByCreator(id_, url.To<std::string>());
     ViewManagerServiceImpl* connection_with_node_as_root =
         root_node_manager_->GetConnectionWithRoot(node_id);
     if ((connection_by_url != connection_with_node_as_root ||
          (!connection_by_url && !connection_with_node_as_root)) &&
         (!connection_by_url || !connection_by_url->HasRoot(node_id))) {
-      RootNodeManager::ScopedChange change(
-          this, root_node_manager_,
-          RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, true);
+      RootNodeManager::ScopedChange change(this, root_node_manager_, true);
       // Never message the originating connection.
       root_node_manager_->OnConnectionMessagedClient(id_);
       if (connection_with_node_as_root)
         connection_with_node_as_root->RemoveRoot(node_id);
       if (connection_by_url)
         connection_by_url->AddRoot(node_id);
       else
         root_node_manager_->Embed(id_, url, transport_node_id);
-      change.SendServerChangeIdAdvanced();
     } else {
       success = false;
     }
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::DispatchOnViewInputEvent(Id transport_view_id,
                                                       EventPtr event) {
   // We only allow the WM to dispatch events. At some point this function will
@@ skipping 19 matching lines @@
   if (roots_.empty()) {
     GetUnknownNodesFrom(root_node_manager_->root(), &to_send);
   } else {
     for (NodeIdSet::const_iterator i = roots_.begin(); i != roots_.end(); ++i)
       GetUnknownNodesFrom(GetNode(NodeIdFromTransportId(*i)), &to_send);
   }
 
   client()->OnViewManagerConnectionEstablished(
       id_,
       creator_url_,
-      root_node_manager_->next_server_change_id(),
       NodesToNodeDatas(to_send));
 }
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo