Consolidates view_manager typedefs

mojo/services/public/cpp/view_manager/tests/view_manager_unittest.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/view_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/public/cpp/application/application.h"
@@ skipping 177 matching lines @@
   node->RemoveObserver(&observer);
 }
 
 
 // Utility class that waits for the destruction of some number of nodes and
 // views.
 class DestructionObserver : public ViewTreeNodeObserver,
                             public ViewObserver {
  public:
   // |nodes| or |views| can be NULL.
-  DestructionObserver(std::set<TransportNodeId>* nodes,
-                      std::set<TransportViewId>* views)
+  DestructionObserver(std::set<Id>* nodes, std::set<Id>* views)
       : nodes_(nodes),
         views_(views) {}
 
  private:
   // Overridden from ViewTreeNodeObserver:
   virtual void OnNodeDestroy(
       ViewTreeNode* node,
       ViewTreeNodeObserver::DispositionChangePhase phase) OVERRIDE {
     if (phase != ViewTreeNodeObserver::DISPOSITION_CHANGED)
       return;
-    std::set<TransportNodeId>::const_iterator it = nodes_->find(node->id());
+    std::set<Id>::const_iterator it = nodes_->find(node->id());
     if (it != nodes_->end())
       nodes_->erase(it);
     if (CanQuit())
       QuitRunLoop();
   }
 
   // Overridden from ViewObserver:
   virtual void OnViewDestroy(
       View* view,
       ViewObserver::DispositionChangePhase phase) OVERRIDE {
     if (phase != ViewObserver::DISPOSITION_CHANGED)
       return;
-    std::set<TransportViewId>::const_iterator it = views_->find(view->id());
+    std::set<Id>::const_iterator it = views_->find(view->id());
     if (it != views_->end())
       views_->erase(it);
     if (CanQuit())
       QuitRunLoop();
   }
 
   bool CanQuit() {
     return (!nodes_ || nodes_->empty()) && (!views_ || views_->empty());
   }
 
-  std::set<TransportNodeId>* nodes_;
-  std::set<TransportViewId>* views_;
+  std::set<Id>* nodes_;
+  std::set<Id>* views_;
 
   DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
 };
 
 void WaitForDestruction(ViewManager* view_manager,
-                        std::set<TransportNodeId>* nodes,
-                        std::set<TransportViewId>* views) {
+                        std::set<Id>* nodes,
+                        std::set<Id>* views) {
   DestructionObserver observer(nodes, views);
   DCHECK(nodes || views);
   if (nodes) {
-    for (std::set<TransportNodeId>::const_iterator it = nodes->begin();
+    for (std::set<Id>::const_iterator it = nodes->begin();
           it != nodes->end(); ++it) {
       view_manager->GetNodeById(*it)->AddObserver(&observer);
     }
   }
   if (views) {
-    for (std::set<TransportViewId>::const_iterator it = views->begin();
+    for (std::set<Id>::const_iterator it = views->begin();
           it != views->end(); ++it) {
       view_manager->GetViewById(*it)->AddObserver(&observer);
     }
   }
   DoRunLoop();
 }
 
 // Tracks a node's destruction. Query is_valid() for current state.
 class NodeTracker : public ViewTreeNodeObserver {
  public:
@@ skipping 211 matching lines @@
 TEST_F(ViewManagerTest, NodeDestroyed) {
   ViewTreeNode* node = ViewTreeNode::Create(window_manager());
   window_manager()->roots().front()->AddChild(node);
   ViewTreeNode* nested = ViewTreeNode::Create(window_manager());
   node->AddChild(nested);
 
   ViewManager* embedded = Embed(window_manager(), node);
   EXPECT_EQ(embedded->roots().front()->children().front()->id(), nested->id());
 
   // |nested| will be deleted after calling Destroy() below.
-  TransportNodeId id = nested->id();
+  Id id = nested->id();
   nested->Destroy();
 
-  std::set<TransportNodeId> nodes;
+  std::set<Id> nodes;
   nodes.insert(id);
   WaitForDestruction(embedded, &nodes, NULL);
 
   EXPECT_TRUE(embedded->roots().front()->children().empty());
   EXPECT_EQ(NULL, embedded->GetNodeById(id));
 }
 
 TEST_F(ViewManagerTest, ViewManagerDestroyed_CleanupNode) {
   ViewTreeNode* node = ViewTreeNode::Create(window_manager());
   window_manager()->roots().front()->AddChild(node);
   ViewManager* embedded = Embed(window_manager(), node);
 
-  TransportNodeId node_id = node->id();
+  Id node_id = node->id();
 
   UnloadApplication(GURL(kWindowManagerURL));
 
-  std::set<TransportNodeId> nodes;
+  std::set<Id> nodes;
   nodes.insert(node_id);
   WaitForDestruction(embedded, &nodes, NULL);
 
   EXPECT_TRUE(embedded->roots().empty());
 }
 
 TEST_F(ViewManagerTest, SetActiveView) {
   ViewTreeNode* node = ViewTreeNode::Create(window_manager());
   window_manager()->roots().front()->AddChild(node);
   ViewManager* embedded = Embed(window_manager(), node);
@@ skipping 13 matching lines @@
   ViewManager* embedded = Embed(window_manager(), node);
 
   View* view = View::Create(window_manager());
   node->SetActiveView(view);
 
   ViewTreeNode* node_in_embedded = embedded->GetNodeById(node->id());
   WaitForActiveViewToChange(node_in_embedded);
 
   EXPECT_EQ(node_in_embedded->active_view()->id(), view->id());
 
-  TransportViewId view_id = view->id();
+  Id view_id = view->id();
   view->Destroy();
 
-  std::set<TransportViewId> views;
+  std::set<Id> views;
   views.insert(view_id);
   WaitForDestruction(embedded, NULL, &views);
   EXPECT_EQ(NULL, node_in_embedded->active_view());
   EXPECT_EQ(NULL, embedded->GetViewById(view_id));
 }
 
 // Destroying the connection that created a node and view should result in that
 // node and view disappearing from all connections that see them.
 TEST_F(ViewManagerTest, ViewManagerDestroyed_CleanupNodeAndView) {
   ViewTreeNode* node = ViewTreeNode::Create(window_manager());
   window_manager()->roots().front()->AddChild(node);
   View* view = View::Create(window_manager());
   node->SetActiveView(view);
   ViewManager* embedded = Embed(window_manager(), node);
 
-  TransportNodeId node_id = node->id();
-  TransportViewId view_id = view->id();
+  Id node_id = node->id();
+  Id view_id = view->id();
 
   UnloadApplication(GURL(kWindowManagerURL));
 
-  std::set<TransportNodeId> observed_nodes;
+  std::set<Id> observed_nodes;
   observed_nodes.insert(node_id);
-  std::set<TransportViewId> observed_views;
+  std::set<Id> observed_views;
   observed_views.insert(view_id);
   WaitForDestruction(embedded, &observed_nodes, &observed_views);
 
   EXPECT_TRUE(embedded->roots().empty());
   EXPECT_EQ(NULL, embedded->GetNodeById(node_id));
   EXPECT_EQ(NULL, embedded->GetViewById(view_id));
 }
 
 // This test validates the following scenario:
 // -  a node originating from one connection
 // -  a view originating from a second connection
 // +  the connection originating the node is destroyed
 // -> the view should still exist (since the second connection is live) but
 //    should be disconnected from any nodes.
 TEST_F(ViewManagerTest,
        ViewManagerDestroyed_CleanupNodeAndViewFromDifferentConnections) {
   ViewTreeNode* node = ViewTreeNode::Create(window_manager());
   window_manager()->roots().front()->AddChild(node);
   ViewManager* embedded = Embed(window_manager(), node);
   View* view_in_embedded = View::Create(embedded);
   ViewTreeNode* node_in_embedded = embedded->GetNodeById(node->id());
   node_in_embedded->SetActiveView(view_in_embedded);
 
   WaitForActiveViewToChange(node);
 
-  TransportNodeId node_id = node->id();
-  TransportViewId view_id = view_in_embedded->id();
+  Id node_id = node->id();
+  Id view_id = view_in_embedded->id();
 
   UnloadApplication(GURL(kWindowManagerURL));
-  std::set<TransportNodeId> nodes;
+  std::set<Id> nodes;
   nodes.insert(node_id);
   WaitForDestruction(embedded, &nodes, NULL);
 
   EXPECT_TRUE(embedded->roots().empty());
   // node was owned by the window manager, so it should be gone.
   EXPECT_EQ(NULL, embedded->GetNodeById(node_id));
   // view_in_embedded was owned by the embedded app, so it should still exist,
   // but disconnected from the node tree.
   EXPECT_EQ(view_in_embedded, embedded->GetViewById(view_id));
   EXPECT_EQ(NULL, view_in_embedded->node());
@@ skipping 97 matching lines @@
   window_manager()->roots().front()->AddChild(node1);
   ViewTreeNode* node2 = ViewTreeNode::Create(window_manager());
   window_manager()->roots().front()->AddChild(node2);
   ViewManager* embedded1 = Embed(window_manager(), node1);
   ViewManager* embedded2 = Embed(window_manager(), node2);
   EXPECT_EQ(embedded1, embedded2);
 }
 
 }  // namespace view_manager
 }  // namespace mojo