Map new subtrees when they are attached to the node hierarchy visible to a connection.

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/run_loop.h"
 #include "mojo/public/cpp/shell/connect.h"
 #include "mojo/public/interfaces/shell/shell.mojom.h"
@@ skipping 33 matching lines @@
     private_view.set_id(view_id);
     private_view.set_node(node);
     // TODO(beng): this broadcasts notifications locally... do we want this? I
     //             don't think so. same story for LocalAddChild above!
     private_node.LocalSetActiveView(view);
     private_manager.AddView(view->id(), view);
   }
   return node;
 }
 
+ViewTreeNode* BuildNodeTree(ViewManager* manager,
+                            const Array<INode>& nodes) {
+  std::vector<ViewTreeNode*> parents;
+  ViewTreeNode* root = NULL;
+  ViewTreeNode* last_node = NULL;
+  for (size_t i = 0; i < nodes.size(); ++i) {
+    if (last_node && nodes[i].parent_id() == last_node->id()) {
+      parents.push_back(last_node);
+    } else if (!parents.empty()) {
+      while (parents.back()->id() != nodes[i].parent_id())
+        parents.pop_back();
+    }
+    ViewTreeNode* node = AddNodeToViewManager(
+        manager,
+        !parents.empty() ? parents.back() : NULL,
+        nodes[i].node_id(),
+        nodes[i].view_id());
+    if (!last_node)
+      root = node;
+    last_node = node;
+  }
+  return root;
+}
+
 class ViewManagerTransaction {
  public:
   virtual ~ViewManagerTransaction() {}
 
   void Commit() {
     DCHECK(!committed_);
     DoCommit();
     committed_ = true;
   }
 
   bool committed() const { return committed_; }
 
-  // General callback to be used for commits to the service.
-  void OnActionCompleted(bool success) {
-    DCHECK(success);
-    DoActionCompleted(success);
-    synchronizer_->RemoveFromPendingQueue(this);
-  }
-
  protected:
   enum TransactionType {
     // View creation and destruction.
     TYPE_CREATE_VIEW,
     TYPE_DESTROY_VIEW,
     // 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.)
@@ skipping 15 matching lines @@
   // 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_++;
   }
 
+  base::Callback<void(bool)> ActionCompletedCallback() {
+    return base::Bind(&ViewManagerTransaction::OnActionCompleted,
+                      base::Unretained(this));
+  }
+
  private:
+  // General callback to be used for commits to the service.
+  void OnActionCompleted(bool success) {
+    DCHECK(success);
+    DoActionCompleted(success);
+    synchronizer_->RemoveFromPendingQueue(this);
+  }
+
   const TransactionType transaction_type_;
   bool committed_;
   ViewManagerSynchronizer* synchronizer_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewManagerTransaction);
 };
 
 class CreateViewTransaction : public ViewManagerTransaction {
  public:
   CreateViewTransaction(TransportViewId view_id,
                         ViewManagerSynchronizer* synchronizer)
       : ViewManagerTransaction(TYPE_CREATE_VIEW, synchronizer),
         view_id_(view_id) {}
   virtual ~CreateViewTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
-    service()->CreateView(
-        view_id_,
-        base::Bind(&ViewManagerTransaction::OnActionCompleted,
-                   base::Unretained(this)));
+    service()->CreateView(view_id_, ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): failure.
   }
 
   const TransportViewId view_id_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateViewTransaction);
 };
 
 class DestroyViewTransaction : public ViewManagerTransaction {
  public:
   DestroyViewTransaction(TransportViewId view_id,
                          ViewManagerSynchronizer* synchronizer)
       : ViewManagerTransaction(TYPE_DESTROY_VIEW, synchronizer),
         view_id_(view_id) {}
   virtual ~DestroyViewTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
-    service()->DeleteView(
-        view_id_,
-        base::Bind(&ViewManagerTransaction::OnActionCompleted,
-                   base::Unretained(this)));
+    service()->DeleteView(view_id_, ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
   }
 
   const TransportViewId view_id_;
 
   DISALLOW_COPY_AND_ASSIGN(DestroyViewTransaction);
 };
 
 class CreateViewTreeNodeTransaction : public ViewManagerTransaction {
  public:
   CreateViewTreeNodeTransaction(TransportNodeId 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)));
+    service()->CreateNode(node_id_, ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): Failure means we tried to create with an extant id for this
     //             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 TransportNodeId 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_,
-        base::Bind(&ViewManagerTransaction::OnActionCompleted,
-                   base::Unretained(this)));
+    service()->DeleteNode(node_id_, ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
   }
 
   const TransportNodeId node_id_;
   DISALLOW_COPY_AND_ASSIGN(DestroyViewTreeNodeTransaction);
 };
 
 class HierarchyTransaction : public ViewManagerTransaction {
@@ skipping 14 matching lines @@
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
     switch (hierarchy_change_type_) {
       case TYPE_ADD:
         service()->AddNode(
             parent_id_,
             child_id_,
             GetAndAdvanceNextServerChangeId(),
-            base::Bind(&ViewManagerTransaction::OnActionCompleted,
-                       base::Unretained(this)));
+            ActionCompletedCallback());
         break;
       case TYPE_REMOVE:
         service()->RemoveNodeFromParent(
             child_id_,
             GetAndAdvanceNextServerChangeId(),
-            base::Bind(&ViewManagerTransaction::OnActionCompleted,
-                       base::Unretained(this)));
+            ActionCompletedCallback());
         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);
 };
 
 class SetActiveViewTransaction : public ViewManagerTransaction {
  public:
   SetActiveViewTransaction(TransportNodeId node_id,
                            TransportViewId view_id,
                            ViewManagerSynchronizer* synchronizer)
       : ViewManagerTransaction(TYPE_SET_ACTIVE_VIEW, synchronizer),
         node_id_(node_id),
         view_id_(view_id) {}
   virtual ~SetActiveViewTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
-    service()->SetView(
-        node_id_,
-        view_id_,
-        base::Bind(&ViewManagerTransaction::OnActionCompleted,
-                   base::Unretained(this)));
+    service()->SetView(node_id_, view_id_, ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
   }
 
   const TransportNodeId node_id_;
   const TransportViewId view_id_;
 
   DISALLOW_COPY_AND_ASSIGN(SetActiveViewTransaction);
 };
@@ skipping 91 matching lines @@
       new SetActiveViewTransaction(node_id, view_id, this));
   Sync();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerSynchronizer, IViewManagerClient implementation:
 
 void ViewManagerSynchronizer::OnConnectionEstablished(
     TransportConnectionId connection_id,
     TransportChangeId next_server_change_id,
-    const mojo::Array<INode>& nodes) {
+    const Array<INode>& nodes) {
   connected_ = true;
   connection_id_ = connection_id;
   next_server_change_id_ = next_server_change_id;
 
-  ViewManagerPrivate private_manager(view_manager_);
-  std::vector<ViewTreeNode*> parents;
-  ViewTreeNode* root = NULL;
-  ViewTreeNode* last_node = NULL;
-  for (size_t i = 0; i < nodes.size(); ++i) {
-    if (last_node && nodes[i].parent_id() == last_node->id()) {
-      parents.push_back(last_node);
-    } else if (!parents.empty()) {
-      while (parents.back()->id() != nodes[i].parent_id())
-        parents.pop_back();
-    }
-    ViewTreeNode* node =
-        AddNodeToViewManager(view_manager_,
-                             !parents.empty() ? parents.back() : NULL,
-                             nodes[i].node_id(),
-                             nodes[i].view_id());
-    if (!last_node)
-      root = node;
-    last_node = node;
-  }
-  private_manager.set_root(root);
+  ViewManagerPrivate(view_manager_).set_root(
+      BuildNodeTree(view_manager_, nodes));
   if (init_loop_)
     init_loop_->Quit();
 
   Sync();
 }
 
 void ViewManagerSynchronizer::OnServerChangeIdAdvanced(
     uint32_t next_server_change_id) {
   next_server_change_id_ = next_server_change_id;
 }
 
 void ViewManagerSynchronizer::OnNodeHierarchyChanged(
     uint32_t node_id,
     uint32_t new_parent_id,
     uint32_t old_parent_id,
     TransportChangeId server_change_id,
-    const mojo::Array<INode>& nodes) {
+    const Array<INode>& nodes) {
   // TODO: deal with |nodes|.
   next_server_change_id_ = server_change_id + 1;
 
-  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);
+  BuildNodeTree(view_manager_, nodes);
 
-    // TODO(beng): view changes.
-  }
+  ViewTreeNode* new_parent = view_manager_->GetNodeById(new_parent_id);
+  ViewTreeNode* old_parent = view_manager_->GetNodeById(old_parent_id);
+  ViewTreeNode* node = view_manager_->GetNodeById(node_id);
   if (new_parent)
     ViewTreeNodePrivate(new_parent).LocalAddChild(node);
   else
     ViewTreeNodePrivate(old_parent).LocalRemoveChild(node);
 }
 
 void ViewManagerSynchronizer::OnNodeDeleted(uint32_t node_id,
                                             uint32_t server_change_id) {
   next_server_change_id_ = server_change_id + 1;
 
@@ skipping 40 matching lines @@
   for (; it != pending_transactions_.end(); ++it) {
     if (!(*it)->committed())
       (*it)->Commit();
   }
 }
 
 void ViewManagerSynchronizer::RemoveFromPendingQueue(
     ViewManagerTransaction* transaction) {
   DCHECK_EQ(transaction, pending_transactions_.front());
   pending_transactions_.erase(pending_transactions_.begin());
+  if (pending_transactions_.empty() && !changes_acked_callback_.is_null())
+    changes_acked_callback_.Run();
 }
 
 }  // namespace view_manager
 }  // namespace mojo