Nukes change_ids from view manager

mojo/services/public/cpp/view_manager/lib/view_manager_client_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/public/cpp/view_manager/lib/view_manager_client_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/connect.h"
@@ skipping 115 matching lines @@
 
   // Overridden to perform transaction-specific commit actions.
   virtual void DoCommit() = 0;
 
   // Overridden to perform transaction-specific cleanup on commit ack from the
   // service.
   virtual void DoActionCompleted(bool success) = 0;
 
   ViewManagerService* service() { return client_->service_; }
 
-  Id GetAndAdvanceNextServerChangeId() {
-    return client_->next_server_change_id_++;
-  }
-
   // TODO(sky): nuke this and covert all to new one, then rename
   // ActionCompletedCallbackWithErrorCode to ActionCompletedCallback.
   base::Callback<void(bool)> ActionCompletedCallback() {
     return base::Bind(&ViewManagerTransaction::OnActionCompleted,
                       base::Unretained(this));
   }
 
   base::Callback<void(ErrorCode)> ActionCompletedCallbackWithErrorCode() {
     return base::Bind(&ViewManagerTransaction::OnActionCompletedWithErrorCode,
                       base::Unretained(this));
@@ skipping 89 matching lines @@
 class DestroyNodeTransaction : public ViewManagerTransaction {
  public:
   DestroyNodeTransaction(Id node_id, ViewManagerClientImpl* client)
       : ViewManagerTransaction(client),
         node_id_(node_id) {}
   virtual ~DestroyNodeTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
-    service()->DeleteNode(node_id_,
-                          GetAndAdvanceNextServerChangeId(),
-                          ActionCompletedCallback());
+    service()->DeleteNode(node_id_, ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
     DCHECK(success);
   }
 
   const Id node_id_;
   DISALLOW_COPY_AND_ASSIGN(DestroyNodeTransaction);
 };
 
 class AddChildTransaction : public ViewManagerTransaction {
  public:
   AddChildTransaction(Id child_id,
                       Id parent_id,
                       ViewManagerClientImpl* client)
       : ViewManagerTransaction(client),
         child_id_(child_id),
         parent_id_(parent_id) {}
   virtual ~AddChildTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
-    service()->AddNode(parent_id_,
-                       child_id_,
-                       GetAndAdvanceNextServerChangeId(),
-                       ActionCompletedCallback());
+    service()->AddNode(parent_id_, child_id_, ActionCompletedCallback());
   }
 
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
     DCHECK(success);
   }
 
   const Id child_id_;
   const Id parent_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AddChildTransaction);
 };
 
 class RemoveChildTransaction : public ViewManagerTransaction {
  public:
   RemoveChildTransaction(Id child_id, ViewManagerClientImpl* client)
       : ViewManagerTransaction(client),
         child_id_(child_id) {}
   virtual ~RemoveChildTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
-    service()->RemoveNodeFromParent(
-        child_id_,
-        GetAndAdvanceNextServerChangeId(),
-        ActionCompletedCallback());
+    service()->RemoveNodeFromParent(child_id_, ActionCompletedCallback());
   }
 
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
     DCHECK(success);
   }
 
   const Id child_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveChildTransaction);
@@ skipping 10 matching lines @@
         relative_id_(relative_id),
         direction_(direction) {}
   virtual ~ReorderNodeTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
     service()->ReorderNode(node_id_,
                            relative_id_,
                            direction_,
-                           GetAndAdvanceNextServerChangeId(),
                            ActionCompletedCallback());
   }
 
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
     DCHECK(success);
   }
 
   const Id node_id_;
   const Id relative_id_;
@@ skipping 124 matching lines @@
                    Id node_id,
                    ViewManagerClientImpl* client)
       : ViewManagerTransaction(client),
         url_(url),
         node_id_(node_id) {}
   virtual ~EmbedTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
-    GetAndAdvanceNextServerChangeId();
     service()->Embed(url_, node_id_, ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
   }
 
   const String url_;
   const Id node_id_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbedTransaction);
@@ skipping 43 matching lines @@
   const bool visible_;
 
   DISALLOW_COPY_AND_ASSIGN(SetVisibleTransaction);
 };
 
 ViewManagerClientImpl::ViewManagerClientImpl(ApplicationConnection* connection,
                                              ViewManagerDelegate* delegate)
     : connected_(false),
       connection_id_(0),
       next_id_(1),
-      next_server_change_id_(0),
       delegate_(delegate),
       dispatcher_(NULL) {}
 
 ViewManagerClientImpl::~ViewManagerClientImpl() {
   delegate_->OnViewManagerDisconnected(this);
   while (!nodes_.empty()) {
     IdToNodeMap::iterator it = nodes_.begin();
     if (OwnsNode(it->second->id()))
       it->second->Destroy();
     else
@@ skipping 170 matching lines @@
 void ViewManagerClientImpl::OnConnectionEstablished() {
   service_ = client();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, ViewManagerClient implementation:
 
 void ViewManagerClientImpl::OnViewManagerConnectionEstablished(
     ConnectionSpecificId connection_id,
     const String& creator_url,
-    Id next_server_change_id,
     Array<NodeDataPtr> nodes) {
   connected_ = true;
   connection_id_ = connection_id;
   creator_url_ = TypeConverter<String, std::string>::ConvertFrom(creator_url);
-  next_server_change_id_ = next_server_change_id;
 
   DCHECK(pending_transactions_.empty());
   AddRoot(BuildNodeTree(this, nodes));
 }
 
 void ViewManagerClientImpl::OnRootAdded(Array<NodeDataPtr> nodes) {
   AddRoot(BuildNodeTree(this, nodes));
 }
 
-void ViewManagerClientImpl::OnServerChangeIdAdvanced(
-    Id next_server_change_id) {
-  next_server_change_id_ = next_server_change_id;
-}
-
 void ViewManagerClientImpl::OnNodeBoundsChanged(Id node_id,
                                                 RectPtr old_bounds,
                                                 RectPtr new_bounds) {
   Node* node = GetNodeById(node_id);
   NodePrivate(node).LocalSetBounds(old_bounds.To<gfx::Rect>(),
                                    new_bounds.To<gfx::Rect>());
 }
 
 void ViewManagerClientImpl::OnNodeHierarchyChanged(
     Id node_id,
     Id new_parent_id,
     Id old_parent_id,
-    Id server_change_id,
     mojo::Array<NodeDataPtr> nodes) {
-  next_server_change_id_ = server_change_id + 1;
-
   BuildNodeTree(this, nodes);
 
   Node* new_parent = GetNodeById(new_parent_id);
   Node* old_parent = GetNodeById(old_parent_id);
   Node* node = GetNodeById(node_id);
   if (new_parent)
     NodePrivate(new_parent).LocalAddChild(node);
   else
     NodePrivate(old_parent).LocalRemoveChild(node);
 }
 
 void ViewManagerClientImpl::OnNodeReordered(Id node_id,
                                             Id relative_node_id,
-                                            OrderDirection direction,
-                                            Id server_change_id) {
-  next_server_change_id_ = server_change_id + 1;
-
+                                            OrderDirection direction) {
   Node* node = GetNodeById(node_id);
   Node* relative_node = GetNodeById(relative_node_id);
-  if (node && relative_node) {
+  if (node && relative_node)
     NodePrivate(node).LocalReorder(relative_node, direction);
-  }
 }
 
-void ViewManagerClientImpl::OnNodeDeleted(Id node_id, Id server_change_id) {
-  next_server_change_id_ = server_change_id + 1;
-
+void ViewManagerClientImpl::OnNodeDeleted(Id node_id) {
   Node* node = GetNodeById(node_id);
   if (node)
     NodePrivate(node).LocalDestroy();
 }
 
 void ViewManagerClientImpl::OnNodeViewReplaced(Id node_id,
                                                Id new_view_id,
                                                Id old_view_id) {
   Node* node = GetNodeById(node_id);
   View* new_view = GetViewById(new_view_id);
@@ skipping 100 matching lines @@
 
 // static
 void ViewManager::ConfigureIncomingConnection(
     ApplicationConnection* connection,
     ViewManagerDelegate* delegate) {
   connection->AddService<ViewManagerClientImpl>(delegate);
 }
 
 }  // namespace view_manager
 }  // namespace mojo