Consolidates view_manager typedefs

mojo/services/view_manager/view_manager_connection.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/view_manager/view_manager_connection.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
 #include "mojo/services/public/cpp/input_events/input_events_type_converters.h"
@@ skipping 17 matching lines @@
   nodes->push_back(node);
 
   std::vector<const Node*> children(node->GetChildren());
   for (size_t i = 0 ; i < children.size(); ++i)
     GetDescendants(children[i], nodes);
 }
 
 }  // namespace
 
 ViewManagerConnection::ViewManagerConnection(RootNodeManager* root_node_manager,
-                                             TransportConnectionId creator_id,
+                                             ConnectionSpecificId creator_id,
                                              const std::string& url)
     : root_node_manager_(root_node_manager),
       id_(root_node_manager_->GetAndAdvanceNextConnectionId()),
       url_(url),
       creator_id_(creator_id),
       delete_on_connection_error_(false) {
 }
 
 ViewManagerConnection::~ViewManagerConnection() {
   // Delete any views we own.
@@ skipping 37 matching lines @@
 }
 
 const View* ViewManagerConnection::GetView(const ViewId& id) const {
   if (id_ == id.connection_id) {
     ViewMap::const_iterator i = view_map_.find(id.view_id);
     return i == view_map_.end() ? NULL : i->second;
   }
   return root_node_manager_->GetView(id);
 }
 
-void ViewManagerConnection::SetRoots(const Array<TransportNodeId>& node_ids) {
+void ViewManagerConnection::SetRoots(const Array<Id>& node_ids) {
   DCHECK(roots_.empty());
   NodeIdSet roots;
   for (size_t i = 0; i < node_ids.size(); ++i) {
     DCHECK(GetNode(NodeIdFromTransportId(node_ids[i])));
     roots.insert(node_ids[i]);
   }
   roots_.swap(roots);
 }
 
 void ViewManagerConnection::OnViewManagerConnectionDestroyed(
-    TransportConnectionId id) {
+    ConnectionSpecificId id) {
   if (creator_id_ == id)
     creator_id_ = kRootConnection;
 }
 
 void ViewManagerConnection::ProcessNodeBoundsChanged(
     const Node* node,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds,
     bool originated_change) {
   if (originated_change)
     return;
-  TransportNodeId node_id = NodeIdToTransportId(node->id());
+  Id node_id = NodeIdToTransportId(node->id());
   if (known_nodes_.count(node_id) > 0) {
     client()->OnNodeBoundsChanged(node_id,
                                   Rect::From(old_bounds),
                                   Rect::From(new_bounds));
   }
 }
 
 void ViewManagerConnection::ProcessNodeHierarchyChanged(
     const Node* node,
     const Node* new_parent,
     const Node* old_parent,
-    TransportChangeId server_change_id,
+    Id server_change_id,
     bool originated_change) {
   if (known_nodes_.count(NodeIdToTransportId(node->id())) > 0) {
     if (originated_change)
       return;
     if (node->id().connection_id != id_ && !IsNodeDescendantOfRoots(node)) {
       // Node was a descendant of roots and is no longer, treat it as though the
       // node was deleted.
       RemoveFromKnown(node);
       client()->OnNodeDeleted(NodeIdToTransportId(node->id()),
                               server_change_id);
@@ skipping 26 matching lines @@
                                    NodesToINodes(to_send));
 }
 
 void ViewManagerConnection::ProcessNodeViewReplaced(
     const Node* node,
     const View* new_view,
     const View* old_view,
     bool originated_change) {
   if (originated_change || !known_nodes_.count(NodeIdToTransportId(node->id())))
     return;
-  const TransportViewId new_view_id = new_view ?
+  const Id new_view_id = new_view ?
       ViewIdToTransportId(new_view->id()) : 0;
-  const TransportViewId old_view_id = old_view ?
+  const Id old_view_id = old_view ?
       ViewIdToTransportId(old_view->id()) : 0;
   client()->OnNodeViewReplaced(NodeIdToTransportId(node->id()),
                                new_view_id, old_view_id);
 }
 
-void ViewManagerConnection::ProcessNodeDeleted(
-    const NodeId& node,
-    TransportChangeId server_change_id,
-    bool originated_change) {
+void ViewManagerConnection::ProcessNodeDeleted(const NodeId& node,
+                                               Id server_change_id,
+                                               bool originated_change) {
   const bool in_known = known_nodes_.erase(NodeIdToTransportId(node)) > 0;
   const bool in_roots = roots_.erase(NodeIdToTransportId(node)) > 0;
 
   if (in_roots && roots_.empty())
     roots_.insert(NodeIdToTransportId(InvalidNodeId()));
 
   if (originated_change)
     return;
 
   if (in_known) {
@@ skipping 146 matching lines @@
   RootNodeManager::ScopedChange change(
       this, root_node_manager_,
       RootNodeManager::CHANGE_TYPE_DONT_ADVANCE_SERVER_CHANGE_ID, false);
   node->SetView(view);
   return true;
 }
 
 void ViewManagerConnection::GetUnknownNodesFrom(
     const Node* node,
     std::vector<const Node*>* nodes) {
-  const TransportNodeId transport_id = NodeIdToTransportId(node->id());
+  const Id transport_id = NodeIdToTransportId(node->id());
   if (known_nodes_.count(transport_id) == 1)
     return;
   nodes->push_back(node);
   known_nodes_.insert(transport_id);
   std::vector<const Node*> children(node->GetChildren());
   for (size_t i = 0 ; i < children.size(); ++i)
     GetUnknownNodesFrom(children[i], nodes);
 }
 
 void ViewManagerConnection::RemoveFromKnown(const Node* node) {
   if (node->id().connection_id == id_)
     return;
   known_nodes_.erase(NodeIdToTransportId(node->id()));
   std::vector<const Node*> children = node->GetChildren();
   for (size_t i = 0; i < children.size(); ++i)
     RemoveFromKnown(children[i]);
 }
 
 bool ViewManagerConnection::AddRoots(
-    const std::vector<TransportNodeId>& node_ids) {
+    const std::vector<Id>& node_ids) {
   std::vector<const Node*> to_send;
   bool did_add_root = false;
   for (size_t i = 0; i < node_ids.size(); ++i) {
     CHECK_EQ(creator_id_, NodeIdFromTransportId(node_ids[i]).connection_id);
     if (roots_.count(node_ids[i]) > 0)
       continue;
 
     did_add_root = true;
     roots_.insert(node_ids[i]);
     if (known_nodes_.count(node_ids[i]) == 0) {
       Node* node = GetNode(NodeIdFromTransportId(node_ids[i]));
       DCHECK(node);
       GetUnknownNodesFrom(node, &to_send);
     }
   }
 
   if (!did_add_root)
     return false;
 
   client()->OnRootsAdded(NodesToINodes(to_send));
   return true;
 }
 
 bool ViewManagerConnection::IsNodeDescendantOfRoots(const Node* node) const {
   if (roots_.empty())
     return true;
   if (!node)
     return false;
-  const TransportNodeId invalid_node_id =
+  const Id invalid_node_id =
       NodeIdToTransportId(InvalidNodeId());
   for (NodeIdSet::const_iterator i = roots_.begin(); i != roots_.end(); ++i) {
     if (*i == invalid_node_id)
       continue;
     const Node* root = GetNode(NodeIdFromTransportId(*i));
     DCHECK(root);
     if (root->Contains(node))
       return true;
   }
   return false;
@@ skipping 60 matching lines @@
     inode->node_id = NodeIdToTransportId(node->id());
     inode->view_id =
         ViewIdToTransportId(node->view() ? node->view()->id() : ViewId());
     inode->bounds = Rect::From(node->bounds());
     array[i] = inode.Pass();
   }
   return array.Pass();
 }
 
 void ViewManagerConnection::CreateNode(
-    TransportNodeId transport_node_id,
+    Id transport_node_id,
     const Callback<void(bool)>& callback) {
   const NodeId node_id(NodeIdFromTransportId(transport_node_id));
   if (node_id.connection_id != id_ ||
       node_map_.find(node_id.node_id) != node_map_.end()) {
     callback.Run(false);
     return;
   }
   node_map_[node_id.node_id] = new Node(this, node_id);
   known_nodes_.insert(transport_node_id);
   callback.Run(true);
 }
 
 void ViewManagerConnection::DeleteNode(
-    TransportNodeId transport_node_id,
+    Id transport_node_id,
     const Callback<void(bool)>& callback) {
   const NodeId node_id(NodeIdFromTransportId(transport_node_id));
   bool did_delete = CanDeleteNode(node_id);
   if (did_delete) {
     ViewManagerConnection* connection = root_node_manager_->GetConnection(
         node_id.connection_id);
     did_delete = connection && connection->DeleteNodeImpl(this, node_id);
   }
   callback.Run(did_delete);
 }
 
 void ViewManagerConnection::AddNode(
-    TransportNodeId parent_id,
-    TransportNodeId child_id,
-    TransportChangeId server_change_id,
+    Id parent_id,
+    Id child_id,
+    Id server_change_id,
     const Callback<void(bool)>& callback) {
   bool success = false;
   if (server_change_id == root_node_manager_->next_server_change_id()) {
     Node* parent = GetNode(NodeIdFromTransportId(parent_id));
     Node* child = GetNode(NodeIdFromTransportId(child_id));
     if (CanAddNode(parent, child)) {
       success = true;
       RootNodeManager::ScopedChange change(
           this, root_node_manager_,
           RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, false);
       parent->Add(child);
     }
   }
   callback.Run(success);
 }
 
 void ViewManagerConnection::RemoveNodeFromParent(
-    TransportNodeId node_id,
-    TransportChangeId server_change_id,
+    Id node_id,
+    Id server_change_id,
     const Callback<void(bool)>& callback) {
   bool success = false;
   if (server_change_id == root_node_manager_->next_server_change_id()) {
     Node* node = GetNode(NodeIdFromTransportId(node_id));
     if (CanRemoveNodeFromParent(node)) {
       success = true;
       RootNodeManager::ScopedChange change(
           this, root_node_manager_,
           RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, false);
       node->GetParent()->Remove(node);
     }
   }
   callback.Run(success);
 }
 
 void ViewManagerConnection::GetNodeTree(
-    TransportNodeId node_id,
+    Id node_id,
     const Callback<void(Array<INodePtr>)>& callback) {
   Node* node = GetNode(NodeIdFromTransportId(node_id));
   std::vector<const Node*> nodes;
   if (CanGetNodeTree(node)) {
     GetDescendants(node, &nodes);
     for (size_t i = 0; i < nodes.size(); ++i)
       known_nodes_.insert(NodeIdToTransportId(nodes[i]->id()));
   }
   callback.Run(NodesToINodes(nodes));
 }
 
 void ViewManagerConnection::CreateView(
-    TransportViewId transport_view_id,
+    Id transport_view_id,
     const Callback<void(bool)>& callback) {
   const ViewId view_id(ViewIdFromTransportId(transport_view_id));
   if (view_id.connection_id != id_ || view_map_.count(view_id.view_id)) {
     callback.Run(false);
     return;
   }
   view_map_[view_id.view_id] = new View(view_id);
   callback.Run(true);
 }
 
 void ViewManagerConnection::DeleteView(
-    TransportViewId transport_view_id,
+    Id transport_view_id,
     const Callback<void(bool)>& callback) {
   const ViewId view_id(ViewIdFromTransportId(transport_view_id));
   bool did_delete = CanDeleteView(view_id);
   if (did_delete) {
     ViewManagerConnection* connection = root_node_manager_->GetConnection(
         view_id.connection_id);
     did_delete = (connection && connection->DeleteViewImpl(this, view_id));
   }
   callback.Run(did_delete);
 }
 
-void ViewManagerConnection::SetView(
-    TransportNodeId transport_node_id,
-    TransportViewId transport_view_id,
-    const Callback<void(bool)>& callback) {
+void ViewManagerConnection::SetView(Id transport_node_id,
+                                    Id transport_view_id,
+                                    const Callback<void(bool)>& callback) {
   Node* node = GetNode(NodeIdFromTransportId(transport_node_id));
   const ViewId view_id(ViewIdFromTransportId(transport_view_id));
   callback.Run(CanSetView(node, view_id) && SetViewImpl(node, view_id));
 }
 
 void ViewManagerConnection::SetViewContents(
-    TransportViewId view_id,
+    Id view_id,
     ScopedSharedBufferHandle buffer,
     uint32_t buffer_size,
     const Callback<void(bool)>& callback) {
   View* view = GetView(ViewIdFromTransportId(view_id));
   if (!view) {
     callback.Run(false);
     return;
   }
   void* handle_data;
   if (MapBuffer(buffer.get(), 0, buffer_size, &handle_data,
                 MOJO_MAP_BUFFER_FLAG_NONE) != MOJO_RESULT_OK) {
     callback.Run(false);
     return;
   }
   SkBitmap bitmap;
   gfx::PNGCodec::Decode(static_cast<const unsigned char*>(handle_data),
                         buffer_size, &bitmap);
   view->SetBitmap(bitmap);
   UnmapBuffer(handle_data);
   callback.Run(true);
 }
 
 void ViewManagerConnection::SetNodeBounds(
-    TransportNodeId node_id,
+    Id node_id,
     RectPtr bounds,
     const Callback<void(bool)>& callback) {
   if (NodeIdFromTransportId(node_id).connection_id != id_) {
     callback.Run(false);
     return;
   }
 
   Node* node = GetNode(NodeIdFromTransportId(node_id));
   if (!node) {
     callback.Run(false);
@@ skipping 59 matching lines @@
 
   client()->OnViewManagerConnectionEstablished(
       id_,
       root_node_manager_->next_server_change_id(),
       NodesToINodes(to_send));
 }
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo