Consolidates view_manager typedefs

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 "mojo/public/cpp/application/connect.h"
 #include "mojo/public/interfaces/service_provider/service_provider.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"
 #include "mojo/services/public/cpp/view_manager/view_observer.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace mojo {
 namespace view_manager {
 
-uint32_t MakeTransportId(uint16_t connection_id, uint16_t local_id) {
+Id MakeTransportId(ConnectionSpecificId connection_id,
+                   ConnectionSpecificId 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,
+                                   Id node_id,
+                                   Id view_id,
                                    const gfx::Rect& bounds) {
   // 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);
   private_node.LocalSetBounds(gfx::Rect(), bounds);
   if (parent)
     ViewTreeNodePrivate(parent).LocalAddChild(node);
@@ skipping 82 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;
 
   IViewManager* service() { return synchronizer_->service_; }
 
-  TransportChangeId GetAndAdvanceNextServerChangeId() {
+  Id 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)
+  CreateViewTransaction(Id 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_, ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): failure.
   }
 
-  const TransportViewId view_id_;
+  const Id view_id_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateViewTransaction);
 };
 
 class DestroyViewTransaction : public ViewManagerTransaction {
  public:
-  DestroyViewTransaction(TransportViewId view_id,
-                         ViewManagerSynchronizer* synchronizer)
+  DestroyViewTransaction(Id 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_, ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
   }
 
-  const TransportViewId view_id_;
+  const Id view_id_;
 
   DISALLOW_COPY_AND_ASSIGN(DestroyViewTransaction);
 };
 
 class CreateViewTreeNodeTransaction : public ViewManagerTransaction {
  public:
-  CreateViewTreeNodeTransaction(TransportNodeId node_id,
+  CreateViewTreeNodeTransaction(Id 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_, 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_;
+  const Id node_id_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateViewTreeNodeTransaction);
 };
 
 class DestroyViewTreeNodeTransaction : public ViewManagerTransaction {
  public:
-  DestroyViewTreeNodeTransaction(TransportNodeId node_id,
+  DestroyViewTreeNodeTransaction(Id 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 {
     GetAndAdvanceNextServerChangeId();
     service()->DeleteNode(node_id_, ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
   }
 
-  const TransportNodeId node_id_;
+  const Id node_id_;
   DISALLOW_COPY_AND_ASSIGN(DestroyViewTreeNodeTransaction);
 };
 
 class HierarchyTransaction : public ViewManagerTransaction {
  public:
   enum HierarchyChangeType {
     TYPE_ADD,
     TYPE_REMOVE
   };
   HierarchyTransaction(HierarchyChangeType hierarchy_change_type,
-                       TransportNodeId child_id,
-                       TransportNodeId parent_id,
+                       Id child_id,
+                       Id parent_id,
                        ViewManagerSynchronizer* synchronizer)
       : ViewManagerTransaction(TYPE_HIERARCHY, synchronizer),
         hierarchy_change_type_(hierarchy_change_type),
         child_id_(child_id),
         parent_id_(parent_id) {}
   virtual ~HierarchyTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
@@ skipping 13 matching lines @@
         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_;
+  const Id child_id_;
+  const Id parent_id_;
 
   DISALLOW_COPY_AND_ASSIGN(HierarchyTransaction);
 };
 
 class SetActiveViewTransaction : public ViewManagerTransaction {
  public:
-  SetActiveViewTransaction(TransportNodeId node_id,
-                           TransportViewId view_id,
+  SetActiveViewTransaction(Id node_id,
+                           Id 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_, ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
   }
 
-  const TransportNodeId node_id_;
-  const TransportViewId view_id_;
+  const Id node_id_;
+  const Id view_id_;
 
   DISALLOW_COPY_AND_ASSIGN(SetActiveViewTransaction);
 };
 
 class SetBoundsTransaction : public ViewManagerTransaction {
  public:
-  SetBoundsTransaction(TransportNodeId node_id,
+  SetBoundsTransaction(Id node_id,
                        const gfx::Rect& bounds,
                        ViewManagerSynchronizer* synchronizer)
       : ViewManagerTransaction(TYPE_SET_BOUNDS, synchronizer),
         node_id_(node_id),
         bounds_(bounds) {}
   virtual ~SetBoundsTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
     service()->SetNodeBounds(
         node_id_, Rect::From(bounds_), ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
   }
 
-  const TransportNodeId node_id_;
+  const Id node_id_;
   const gfx::Rect bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(SetBoundsTransaction);
 };
 
 class SetViewContentsTransaction : public ViewManagerTransaction {
  public:
-  SetViewContentsTransaction(TransportViewId view_id,
+  SetViewContentsTransaction(Id view_id,
                              const SkBitmap& contents,
                              ViewManagerSynchronizer* synchronizer)
       : ViewManagerTransaction(TYPE_SET_VIEW_CONTENTS, synchronizer),
         view_id_(view_id),
         contents_(contents) {}
   virtual ~SetViewContentsTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
@@ skipping 35 matching lines @@
 
     result = MapBuffer(
         handle->get(), 0, size, memory, MOJO_MAP_BUFFER_FLAG_NONE);
     if (result != MOJO_RESULT_OK)
       return false;
     DCHECK(*memory);
 
     return true;
   }
 
-  const TransportViewId view_id_;
+  const Id view_id_;
   const SkBitmap contents_;
   ScopedSharedBufferHandle shared_state_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(SetViewContentsTransaction);
 };
 
 class EmbedTransaction : public ViewManagerTransaction {
  public:
   EmbedTransaction(const String& url,
-                   TransportNodeId node_id,
+                   Id node_id,
                    ViewManagerSynchronizer* synchronizer)
       : ViewManagerTransaction(TYPE_EMBED, synchronizer),
         url_(url),
         node_id_(node_id) {}
   virtual ~EmbedTransaction() {}
 
  private:
   // Overridden from ViewManagerTransaction:
   virtual void DoCommit() OVERRIDE {
-    std::vector<TransportNodeId> ids;
+    std::vector<Id> ids;
     ids.push_back(node_id_);
-    service()->Connect(url_, Array<TransportNodeId>::From(ids),
+    service()->Connect(url_, Array<Id>::From(ids),
                        ActionCompletedCallback());
   }
   virtual void DoActionCompleted(bool success) OVERRIDE {
     // TODO(beng): recovery?
   }
 
   const String url_;
-  const TransportNodeId node_id_;
+  const Id node_id_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbedTransaction);
 };
 
 ViewManagerSynchronizer::ViewManagerSynchronizer(ViewManagerDelegate* delegate)
     : view_manager_(new ViewManager(this, delegate)),
       connected_(false),
       connection_id_(0),
       next_id_(1),
       next_server_change_id_(0),
       sync_factory_(this) {
 }
 
 ViewManagerSynchronizer::~ViewManagerSynchronizer() {
 }
 
-TransportNodeId ViewManagerSynchronizer::CreateViewTreeNode() {
+Id ViewManagerSynchronizer::CreateViewTreeNode() {
   DCHECK(connected_);
-  const TransportNodeId node_id(
-      MakeTransportId(connection_id_, ++next_id_));
+  const Id node_id(MakeTransportId(connection_id_, ++next_id_));
   pending_transactions_.push_back(
       new CreateViewTreeNodeTransaction(node_id, this));
   Sync();
   return node_id;
 }
 
-void ViewManagerSynchronizer::DestroyViewTreeNode(TransportNodeId node_id) {
+void ViewManagerSynchronizer::DestroyViewTreeNode(Id node_id) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new DestroyViewTreeNodeTransaction(node_id, this));
   Sync();
 }
 
-TransportViewId ViewManagerSynchronizer::CreateView() {
+Id ViewManagerSynchronizer::CreateView() {
   DCHECK(connected_);
-  const TransportNodeId view_id(
-      MakeTransportId(connection_id_, ++next_id_));
+  const Id view_id(MakeTransportId(connection_id_, ++next_id_));
   pending_transactions_.push_back(new CreateViewTransaction(view_id, this));
   Sync();
   return view_id;
 }
 
-void ViewManagerSynchronizer::DestroyView(TransportViewId view_id) {
+void ViewManagerSynchronizer::DestroyView(Id view_id) {
   DCHECK(connected_);
   pending_transactions_.push_back(new DestroyViewTransaction(view_id, this));
   Sync();
 }
 
-void ViewManagerSynchronizer::AddChild(TransportNodeId child_id,
-                                       TransportNodeId parent_id) {
+void ViewManagerSynchronizer::AddChild(Id child_id,
+                                       Id parent_id) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new HierarchyTransaction(HierarchyTransaction::TYPE_ADD,
                                child_id,
                                parent_id,
                                this));
   Sync();
 }
 
-void ViewManagerSynchronizer::RemoveChild(TransportNodeId child_id,
-                                          TransportNodeId parent_id) {
+void ViewManagerSynchronizer::RemoveChild(Id child_id, Id parent_id) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new HierarchyTransaction(HierarchyTransaction::TYPE_REMOVE,
                                child_id,
                                parent_id,
                                this));
   Sync();
 }
 
-bool ViewManagerSynchronizer::OwnsNode(TransportNodeId id) const {
+bool ViewManagerSynchronizer::OwnsNode(Id id) const {
   return HiWord(id) == connection_id_;
 }
 
-bool ViewManagerSynchronizer::OwnsView(TransportViewId id) const {
+bool ViewManagerSynchronizer::OwnsView(Id id) const {
   return HiWord(id) == connection_id_;
 }
 
-void ViewManagerSynchronizer::SetActiveView(TransportNodeId node_id,
-                                            TransportViewId view_id) {
+void ViewManagerSynchronizer::SetActiveView(Id node_id, Id view_id) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new SetActiveViewTransaction(node_id, view_id, this));
   Sync();
 }
 
-void ViewManagerSynchronizer::SetBounds(TransportNodeId node_id,
-                                        const gfx::Rect& bounds) {
+void ViewManagerSynchronizer::SetBounds(Id node_id, const gfx::Rect& bounds) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new SetBoundsTransaction(node_id, bounds, this));
   Sync();
 }
 
-void ViewManagerSynchronizer::SetViewContents(TransportViewId view_id,
+void ViewManagerSynchronizer::SetViewContents(Id view_id,
                                               const SkBitmap& contents) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new SetViewContentsTransaction(view_id, contents, this));
   Sync();
 }
 
-void ViewManagerSynchronizer::Embed(const String& url,
-                                    TransportNodeId node_id) {
+void ViewManagerSynchronizer::Embed(const String& url, Id node_id) {
   DCHECK(connected_);
   pending_transactions_.push_back(new EmbedTransaction(url, node_id, this));
   Sync();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerSynchronizer, InterfaceImpl overrides:
 
 void ViewManagerSynchronizer::OnConnectionEstablished() {
   service_ = client();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerSynchronizer, IViewManagerClient implementation:
 
 void ViewManagerSynchronizer::OnViewManagerConnectionEstablished(
-    TransportConnectionId connection_id,
-    TransportChangeId next_server_change_id,
+    ConnectionSpecificId connection_id,
+    Id next_server_change_id,
     mojo::Array<INodePtr> nodes) {
   connected_ = true;
   connection_id_ = connection_id;
   next_server_change_id_ = next_server_change_id;
 
   DCHECK(pending_transactions_.empty());
   ViewManagerPrivate private_manager(view_manager());
   private_manager.AddRoot(BuildNodeTree(view_manager(), nodes));
 }
 
 void ViewManagerSynchronizer::OnRootsAdded(Array<INodePtr> nodes) {
   ViewManagerPrivate private_manager(view_manager());
   private_manager.AddRoot(BuildNodeTree(view_manager(), nodes));
 }
 
 void ViewManagerSynchronizer::OnServerChangeIdAdvanced(
-    uint32_t next_server_change_id) {
+    Id next_server_change_id) {
   next_server_change_id_ = next_server_change_id;
 }
 
-void ViewManagerSynchronizer::OnNodeBoundsChanged(uint32 node_id,
+void ViewManagerSynchronizer::OnNodeBoundsChanged(Id node_id,
                                                   RectPtr old_bounds,
                                                   RectPtr new_bounds) {
   ViewTreeNode* node = view_manager()->GetNodeById(node_id);
   ViewTreeNodePrivate(node).LocalSetBounds(old_bounds.To<gfx::Rect>(),
                                            new_bounds.To<gfx::Rect>());
 }
 
 void ViewManagerSynchronizer::OnNodeHierarchyChanged(
-    uint32_t node_id,
-    uint32_t new_parent_id,
-    uint32_t old_parent_id,
-    TransportChangeId server_change_id,
+    Id node_id,
+    Id new_parent_id,
+    Id old_parent_id,
+    Id server_change_id,
     mojo::Array<INodePtr> nodes) {
   // TODO: deal with |nodes|.
   next_server_change_id_ = server_change_id + 1;
 
   BuildNodeTree(view_manager(), nodes);
 
   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) {
+void ViewManagerSynchronizer::OnNodeDeleted(Id node_id, Id server_change_id) {
   next_server_change_id_ = server_change_id + 1;
 
   ViewTreeNode* node = view_manager()->GetNodeById(node_id);
   if (node)
     ViewTreeNodePrivate(node).LocalDestroy();
 }
 
-void ViewManagerSynchronizer::OnNodeViewReplaced(uint32_t node_id,
-                                                 uint32_t new_view_id,
-                                                 uint32_t old_view_id) {
+void ViewManagerSynchronizer::OnNodeViewReplaced(Id node_id,
+                                                 Id new_view_id,
+                                                 Id old_view_id) {
   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::OnViewDeleted(uint32_t view_id) {
+void ViewManagerSynchronizer::OnViewDeleted(Id view_id) {
   View* view = view_manager()->GetViewById(view_id);
   if (view)
     ViewPrivate(view).LocalDestroy();
 }
 
 void ViewManagerSynchronizer::OnViewInputEvent(
-    uint32_t view_id,
+    Id view_id,
     EventPtr event,
     const Callback<void()>& ack_callback) {
   View* view = view_manager_->GetViewById(view_id);
   if (view) {
     FOR_EACH_OBSERVER(ViewObserver,
                       *ViewPrivate(view).observers(),
                       OnViewInputEvent(view, event.Pass()));
   }
   ack_callback.Run();
 }
@@ skipping 17 matching lines @@
 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