View synchronization

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_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;
+uint32_t MakeTransportId(uint16_t connection_id, uint16_t local_id) {
+  return (connection_id << 16) | local_id;
+}
+
+// Helper called to construct a local node/view object from transport data.
+ViewTreeNode* AddNodeToViewManager(ViewManager* manager,
+                                   ViewTreeNode* parent,
+                                   TransportNodeId node_id,
+                                   TransportViewId view_id) {
+  // We don't use the ctor that takes a ViewManager here, since it will call
+  // back to the service and attempt to create a new node.
+  ViewTreeNode* node = ViewTreeNodePrivate::LocalCreate();
+  ViewTreeNodePrivate private_node(node);
+  private_node.set_view_manager(manager);
+  private_node.set_id(node_id);
+  if (parent)
+    ViewTreeNodePrivate(parent).LocalAddChild(node);
+  ViewManagerPrivate private_manager(manager);
+  private_manager.AddNode(node->id(), node);
+
+  // View.
+  if (view_id != 0) {
+    View* view = ViewPrivate::LocalCreate();
+    ViewPrivate private_view(view);
+    private_view.set_view_manager(manager);
+    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;
 }
 
 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_; }
 
   // 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.)
-    TYPE_HIERARCHY
+    TYPE_HIERARCHY,
+    // View replacement.
+    TYPE_SET_ACTIVE_VIEW
   };
 
   ViewManagerTransaction(TransactionType transaction_type,
                          ViewManagerSynchronizer* synchronizer)
       : transaction_type_(transaction_type),
         change_id_(synchronizer->GetNextChangeId()),
         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(); }
 
  private:
   const TransactionType transaction_type_;
   const uint32_t change_id_;
   bool committed_;
   ViewManagerSynchronizer* synchronizer_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewManagerTransaction);
 };
 
+class CreateViewTransaction : public ViewManagerTransaction {
+ public:
+  CreateViewTransaction(uint16_t 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)));
+  }
+  virtual void DoActionCompleted(bool success) OVERRIDE {
+    // TODO(beng): failure.
+  }
+
+  const uint16_t 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_,
+        change_id(),
+        base::Bind(&ViewManagerTransaction::OnActionCompleted,
+                   base::Unretained(this)));
+  }
+  virtual void DoActionCompleted(bool success) OVERRIDE {
+    // TODO(beng): recovery?
+  }
+
+  const TransportViewId view_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(DestroyViewTransaction);
+};
+
 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:
@@ skipping 27 matching lines @@
     service()->DeleteNode(
         node_id_,
         change_id(),
         base::Bind(&ViewManagerTransaction::OnActionCompleted,
                    base::Unretained(this)));
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
   }
 
-  TransportNodeId node_id_;
+  const TransportNodeId node_id_;
   DISALLOW_COPY_AND_ASSIGN(DestroyViewTreeNodeTransaction);
 };
 
 class HierarchyTransaction : public ViewManagerTransaction {
  public:
   enum HierarchyChangeType {
     TYPE_ADD,
     TYPE_REMOVE
   };
   HierarchyTransaction(HierarchyChangeType hierarchy_change_type,
@@ skipping 33 matching lines @@
     //             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_,
+        change_id(),
+        base::Bind(&ViewManagerTransaction::OnActionCompleted,
+                   base::Unretained(this)));
+  }
+  virtual void DoActionCompleted(bool success) OVERRIDE {
+    // TODO(beng): recovery?
+  }
+
+  const TransportNodeId node_id_;
+  const TransportViewId view_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(SetActiveViewTransaction);
+};
+
 ViewManagerSynchronizer::ViewManagerSynchronizer(ViewManager* view_manager)
     : view_manager_(view_manager),
       connected_(false),
       connection_id_(0),
       next_id_(1),
       next_change_id_(0),
       sync_factory_(this),
       init_loop_(NULL) {
   ConnectTo(ViewManagerPrivate(view_manager_).shell(), "mojo:mojo_view_manager",
             &service_);
@@ skipping 13 matching lines @@
 
 ViewManagerSynchronizer::~ViewManagerSynchronizer() {
   DoSync();
 }
 
 TransportNodeId ViewManagerSynchronizer::CreateViewTreeNode() {
   DCHECK(connected_);
   uint16_t id = ++next_id_;
   pending_transactions_.push_back(new CreateViewTreeNodeTransaction(id, this));
   ScheduleSync();
-  return MakeTransportNodeId(connection_id_, id);
+  return MakeTransportId(connection_id_, id);
 }
 
 void ViewManagerSynchronizer::DestroyViewTreeNode(TransportNodeId node_id) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new DestroyViewTreeNodeTransaction(node_id, this));
   ScheduleSync();
 }
 
+TransportViewId ViewManagerSynchronizer::CreateView() {
+  DCHECK(connected_);
+  uint16_t id = ++next_id_;
+  pending_transactions_.push_back(new CreateViewTransaction(id, this));
+  ScheduleSync();
+  return MakeTransportId(connection_id_, id);
+}
+
+void ViewManagerSynchronizer::DestroyView(TransportViewId view_id) {
+  DCHECK(connected_);
+  pending_transactions_.push_back(new DestroyViewTransaction(view_id, this));
+  ScheduleSync();
+}
+
 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();
 }
 
 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();
 }
 
 bool ViewManagerSynchronizer::OwnsNode(TransportNodeId id) const {
   return HiWord(id) == connection_id_;
 }
 
+bool ViewManagerSynchronizer::OwnsView(TransportViewId id) const {
+  return HiWord(id) == connection_id_;
+}
+
+void ViewManagerSynchronizer::SetActiveView(TransportNodeId node_id,
+                                            TransportViewId view_id) {
+  DCHECK(connected_);
+  pending_transactions_.push_back(
+      new SetActiveViewTransaction(node_id, view_id, this));
+  ScheduleSync();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerSynchronizer, IViewManagerClient implementation:
 
 void ViewManagerSynchronizer::OnConnectionEstablished(uint16 connection_id) {
   connected_ = true;
   connection_id_ = connection_id;
   ScheduleSync();
 }
 
 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);
     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);
+
+      // TODO(beng): view changes.
     }
     if (new_parent)
       ViewTreeNodePrivate(new_parent).LocalAddChild(node);
     else
       ViewTreeNodePrivate(old_parent).LocalRemoveChild(node);
   }
 }
 
-void ViewManagerSynchronizer::OnNodeViewReplaced(uint32_t node,
+void ViewManagerSynchronizer::OnNodeViewReplaced(uint32_t node_id,
                                                  uint32_t new_view_id,
                                                  uint32_t old_view_id,
                                                  uint32_t change_id) {
-  // ..
+  if (change_id == 0) {
+    ViewTreeNode* node = view_manager_->GetNodeById(node_id);
+    View* new_view = view_manager_->GetViewById(new_view_id);
+    if (!new_view && new_view_id != 0) {
+      // This client wasn't aware of this View until now.
+      new_view = ViewPrivate::LocalCreate();
+      ViewPrivate private_view(new_view);
+      private_view.set_view_manager(view_manager_);
+      private_view.set_id(new_view_id);
+      private_view.set_node(node);
+      ViewManagerPrivate(view_manager_).AddView(new_view->id(), new_view);
+    }
+    View* old_view = view_manager_->GetViewById(old_view_id);
+    DCHECK_EQ(old_view, node->active_view());
+    ViewTreeNodePrivate(node).LocalSetActiveView(new_view);
+  }
 }
 
 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();
   }
 }
 
+void ViewManagerSynchronizer::OnViewDeleted(uint32_t view_id,
+                                            uint32_t change_id) {
+  if (change_id == 0) {
+    View* view = view_manager_->GetViewById(view_id);
+    if (view)
+      ViewPrivate(view).LocalDestroy();
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerSynchronizer, private:
 
 void ViewManagerSynchronizer::ScheduleSync() {
   if (sync_factory_.HasWeakPtrs())
     return;
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ViewManagerSynchronizer::DoSync, sync_factory_.GetWeakPtr()));
 }
@@ skipping 21 matching lines @@
 }
 
 void ViewManagerSynchronizer::RemoveFromPendingQueue(
     ViewManagerTransaction* transaction) {
   DCHECK_EQ(transaction, pending_transactions_.front());
   pending_transactions_.erase(pending_transactions_.begin());
 }
 
 void ViewManagerSynchronizer::OnRootTreeReceived(
     const Array<INode>& nodes) {
+  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();
     }
-    // We don't use the ctor that takes a ViewManager here, since it will call
-    // back to the service and attempt to create a new node.
-    ViewTreeNode* node = ViewTreeNodePrivate::LocalCreate();
-    ViewTreeNodePrivate private_node(node);
-    private_node.set_view_manager(view_manager_);
-    private_node.set_id(nodes[i].node_id());
-    if (!parents.empty())
-      ViewTreeNodePrivate(parents.back()).LocalAddChild(node);
+    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;
-    ViewManagerPrivate(view_manager_).AddNode(node->id(), node);
   }
-  ViewManagerPrivate(view_manager_).set_root(root);
+  private_manager.set_root(root);
   if (init_loop_)
     init_loop_->Quit();
 }
 
 }  // namespace view_manager
 }  // namespace services
 }  // namespace mojo