Introduces another change id to hierarchy mutations

mojo/services/public/cpp/view_manager/lib/view_manager_synchronizer.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_synchronizer.h"
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/shell/service.h"
 #include "mojo/public/interfaces/shell/shell.mojom.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_manager_private.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_tree_node_private.h"
 #include "mojo/services/public/cpp/view_manager/util.h"
 
 namespace mojo {
 namespace services {
 namespace view_manager {
 
 TransportNodeId MakeTransportNodeId(uint16_t connection_id,
                                     uint16_t local_node_id) {
   return (connection_id << 16) | local_node_id;
 }
 
 class ViewManagerTransaction {
  public:
   virtual ~ViewManagerTransaction() {}
 
   void Commit() {
     DCHECK(!committed_);
     DoCommit();
     committed_ = true;
   }
 
   bool committed() const { return committed_; }
-  uint32_t change_id() const { return change_id_; }
+  TransportChangeId client_change_id() const { return client_change_id_; }
 
   // General callback to be used for commits to the service.
   void OnActionCompleted(bool success) {
     DCHECK(success);
     DoActionCompleted(success);
     synchronizer_->RemoveFromPendingQueue(this);
   }
 
  protected:
   enum TransactionType {
     // Node creation and destruction.
     TYPE_CREATE_VIEW_TREE_NODE,
     TYPE_DESTROY_VIEW_TREE_NODE,
     // Modifications to the hierarchy (addition of or removal of nodes from a
     // parent.)
     TYPE_HIERARCHY
   };
 
   ViewManagerTransaction(TransactionType transaction_type,
                          ViewManagerSynchronizer* synchronizer)
       : transaction_type_(transaction_type),
-        change_id_(synchronizer->GetNextChangeId()),
+        client_change_id_(synchronizer->GetNextClientChangeId()),
         committed_(false),
         synchronizer_(synchronizer) {
   }
 
   // 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;
 
   IViewManager* service() { return synchronizer_->service_.get(); }
 
+  TransportChangeId GetAndAdvanceNextServerChangeId() {
+    return synchronizer_->next_server_change_id_++;
+  }
+
  private:
   const TransactionType transaction_type_;
-  const uint32_t change_id_;
+  const uint32_t client_change_id_;
   bool committed_;
   ViewManagerSynchronizer* synchronizer_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewManagerTransaction);
 };
 
 class CreateViewTreeNodeTransaction : public ViewManagerTransaction {
  public:
   CreateViewTreeNodeTransaction(uint16_t node_id,
                                 ViewManagerSynchronizer* synchronizer)
       : ViewManagerTransaction(TYPE_CREATE_VIEW_TREE_NODE, synchronizer),
         node_id_(node_id) {}
   virtual ~CreateViewTreeNodeTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
     service()->CreateNode(
         node_id_,
         base::Bind(&ViewManagerTransaction::OnActionCompleted,
                    base::Unretained(this)));
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): Failure means we tried to create with an extant id for this
-    //             connection. Figure out what to do.
+    //             connection. It also could mean we tried to do something
+    //             invalid, or we tried applying a change out of order. Figure
+    //             out what to do.
   }
 
   const uint16_t node_id_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateViewTreeNodeTransaction);
 };
 
 class DestroyViewTreeNodeTransaction : public ViewManagerTransaction {
  public:
   DestroyViewTreeNodeTransaction(TransportNodeId node_id,
                                  ViewManagerSynchronizer* synchronizer)
       : ViewManagerTransaction(TYPE_DESTROY_VIEW_TREE_NODE, synchronizer),
         node_id_(node_id) {}
   virtual ~DestroyViewTreeNodeTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
     service()->DeleteNode(
         node_id_,
-        change_id(),
+        client_change_id(),
         base::Bind(&ViewManagerTransaction::OnActionCompleted,
                    base::Unretained(this)));
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
   }
 
   TransportNodeId node_id_;
   DISALLOW_COPY_AND_ASSIGN(DestroyViewTreeNodeTransaction);
 };
@@ skipping 15 matching lines @@
   virtual ~HierarchyTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
     switch (hierarchy_change_type_) {
       case TYPE_ADD:
         service()->AddNode(
             parent_id_,
             child_id_,
-            change_id(),
+            GetAndAdvanceNextServerChangeId(),
+            client_change_id(),
             base::Bind(&ViewManagerTransaction::OnActionCompleted,
                        base::Unretained(this)));
         break;
       case TYPE_REMOVE:
         service()->RemoveNodeFromParent(
             child_id_,
-            change_id(),
+            GetAndAdvanceNextServerChangeId(),
+            client_change_id(),
             base::Bind(&ViewManagerTransaction::OnActionCompleted,
                        base::Unretained(this)));
         break;
     }
   }
 
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): Failure means either one of the nodes specified didn't exist,
     //             or we passed the same node id for both params. Roll back?
   }
 
   const HierarchyChangeType hierarchy_change_type_;
   const TransportNodeId child_id_;
   const TransportNodeId parent_id_;
 
   DISALLOW_COPY_AND_ASSIGN(HierarchyTransaction);
 };
 
 ViewManagerSynchronizer::ViewManagerSynchronizer(ViewManager* view_manager)
     : view_manager_(view_manager),
       connected_(false),
       connection_id_(0),
       next_id_(1),
-      next_change_id_(0),
+      next_client_change_id_(0),
+      next_server_change_id_(0),
       sync_factory_(this),
       init_loop_(NULL) {
   ConnectTo(ViewManagerPrivate(view_manager_).shell(), "mojo:mojo_view_manager",
             &service_);
   service_->SetClient(this);
 
   AllocationScope scope;
   service_->GetNodeTree(
       1,
       base::Bind(&ViewManagerSynchronizer::OnRootTreeReceived,
                  base::Unretained(this)));
 
   base::RunLoop loop;
   init_loop_ = &loop;
   init_loop_->Run();
   init_loop_ = NULL;
 }
 
 ViewManagerSynchronizer::~ViewManagerSynchronizer() {
-  DoSync();
+  Sync();
 }
 
 TransportNodeId ViewManagerSynchronizer::CreateViewTreeNode() {
   DCHECK(connected_);
   uint16_t id = ++next_id_;
   pending_transactions_.push_back(new CreateViewTreeNodeTransaction(id, this));
-  ScheduleSync();
+  Sync();
   return MakeTransportNodeId(connection_id_, id);
 }
 
 void ViewManagerSynchronizer::DestroyViewTreeNode(TransportNodeId node_id) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new DestroyViewTreeNodeTransaction(node_id, this));
-  ScheduleSync();
+  Sync();
 }
 
 void ViewManagerSynchronizer::AddChild(TransportNodeId child_id,
                                        TransportNodeId parent_id) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new HierarchyTransaction(HierarchyTransaction::TYPE_ADD,
                                child_id,
                                parent_id,
                                this));
-  ScheduleSync();
+  Sync();
 }
 
 void ViewManagerSynchronizer::RemoveChild(TransportNodeId child_id,
                                           TransportNodeId parent_id) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new HierarchyTransaction(HierarchyTransaction::TYPE_REMOVE,
                                child_id,
                                parent_id,
                                this));
-  ScheduleSync();
+  Sync();
 }
 
 bool ViewManagerSynchronizer::OwnsNode(TransportNodeId id) const {
   return HiWord(id) == connection_id_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerSynchronizer, IViewManagerClient implementation:
 
-void ViewManagerSynchronizer::OnConnectionEstablished(uint16 connection_id) {
+void ViewManagerSynchronizer::OnConnectionEstablished(
+    TransportConnectionId connection_id,
+    TransportChangeId next_server_change_id) {
   connected_ = true;
   connection_id_ = connection_id;
-  ScheduleSync();
+  next_server_change_id_ = next_server_change_id;
+  Sync();
 }
 
-void ViewManagerSynchronizer::OnNodeHierarchyChanged(uint32_t node_id,
-                                                     uint32_t new_parent_id,
-                                                     uint32_t old_parent_id,
-                                                     uint32_t change_id) {
-  if (change_id == 0) {
-    ViewTreeNode* new_parent = view_manager_->GetNodeById(new_parent_id);
-    ViewTreeNode* old_parent = view_manager_->GetNodeById(old_parent_id);
+void ViewManagerSynchronizer::OnNodeHierarchyChanged(
+    uint32_t node_id,
+    uint32_t new_parent_id,
+    uint32_t old_parent_id,
+    TransportChangeId server_change_id,
+    TransportChangeId client_change_id) {
+  if (client_change_id == 0) {
+    // Change originated from another client.
+    ViewTreeNode* new_parent =
+        view_manager_->tree()->GetChildById(new_parent_id);
+    ViewTreeNode* old_parent =
+        view_manager_->tree()->GetChildById(old_parent_id);
     ViewTreeNode* node = NULL;
     if (old_parent) {
       // Existing node, mapped in this connection's tree.
       // TODO(beng): verify this is actually true.
       node = view_manager_->GetNodeById(node_id);
       DCHECK_EQ(node->parent(), old_parent);
     } else {
       // New node, originating from another connection.
       node = ViewTreeNodePrivate::LocalCreate();
       ViewTreeNodePrivate private_node(node);
       private_node.set_view_manager(view_manager_);
       private_node.set_id(node_id);
       ViewManagerPrivate(view_manager_).AddNode(node->id(), node);
     }
     if (new_parent)
       ViewTreeNodePrivate(new_parent).LocalAddChild(node);
     else
       ViewTreeNodePrivate(old_parent).LocalRemoveChild(node);
   }
+  next_server_change_id_ = server_change_id + 1;
+}
+
+void ViewManagerSynchronizer::OnNodeDeleted(
+    TransportNodeId node_id,
+    TransportChangeId server_change_id,
+    TransportChangeId client_change_id) {
+  next_server_change_id_ = server_change_id + 1;
+  if (client_change_id == 0) {
+    ViewTreeNode* node = view_manager_->GetNodeById(node_id);
+    if (node)
+      ViewTreeNodePrivate(node).LocalDestroy();
+  }
 }
 
 void ViewManagerSynchronizer::OnNodeViewReplaced(uint32_t node,
                                                  uint32_t new_view_id,
                                                  uint32_t old_view_id,
-                                                 uint32_t change_id) {
+                                                 uint32_t client_change_id) {
   // ..
 }
 
-void ViewManagerSynchronizer::OnNodeDeleted(uint32_t node_id,
-                                            uint32_t change_id) {
-  if (change_id == 0) {
-    ViewTreeNode* node = view_manager_->GetNodeById(node_id);
-    if (node)
-      ViewTreeNodePrivate(node).LocalDestroy();
-  }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerSynchronizer, private:
 
-void ViewManagerSynchronizer::ScheduleSync() {
-  if (sync_factory_.HasWeakPtrs())
-    return;
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&ViewManagerSynchronizer::DoSync, sync_factory_.GetWeakPtr()));
-}
-
-void ViewManagerSynchronizer::DoSync() {
+void ViewManagerSynchronizer::Sync() {
   // The service connection may not be set up yet. OnConnectionEstablished()
   // will schedule another sync when it is.
   if (!connected_)
     return;
 
   Transactions::const_iterator it = pending_transactions_.begin();
   for (; it != pending_transactions_.end(); ++it) {
     if (!(*it)->committed())
       (*it)->Commit();
   }
 }
 
-uint32_t ViewManagerSynchronizer::GetNextChangeId() {
+uint32_t ViewManagerSynchronizer::GetNextClientChangeId() {
   // TODO(beng): deal with change id collisions? Important in the "never ack'ed
   //             change" case mentioned in OnNodeHierarchyChanged().
   // "0" is a special value passed to other connected clients, so we can't use
   // it.
-  next_change_id_ = std::max(1u, next_change_id_ + 1);
-  return next_change_id_;
+  next_client_change_id_ = std::max(1u, next_client_change_id_ + 1);
+  return next_client_change_id_;
 }
 
 void ViewManagerSynchronizer::RemoveFromPendingQueue(
     ViewManagerTransaction* transaction) {
   DCHECK_EQ(transaction, pending_transactions_.front());
   pending_transactions_.erase(pending_transactions_.begin());
 }
 
 void ViewManagerSynchronizer::OnRootTreeReceived(
     const Array<INode>& nodes) {
@@ skipping 21 matching lines @@
     ViewManagerPrivate(view_manager_).AddNode(node->id(), node);
   }
   ViewManagerPrivate(view_manager_).set_root(root);
   if (init_loop_)
     init_loop_->Quit();
 }
 
 }  // namespace view_manager
 }  // namespace services
 }  // namespace mojo