Consolidates view_manager typedefs

mojo/services/view_manager/view_manager_connection_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 <string>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 67 matching lines @@
 
   const std::vector<Change>& changes() const { return changes_; }
 
   // Destroys the connection, blocking until done.
   void Destroy() {
     router_->CloseMessagePipe();
   }
 
   // The following functions are cover methods for IViewManager. They block
   // until the result is received.
-  bool CreateNode(TransportNodeId node_id) {
+  bool CreateNode(Id node_id) {
     changes_.clear();
     bool result = false;
     view_manager_->CreateNode(node_id,
                               base::Bind(&ViewManagerProxy::GotResult,
                                          base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
-  bool AddNode(TransportNodeId parent,
-               TransportNodeId child,
-               TransportChangeId server_change_id) {
+  bool AddNode(Id parent, Id child, Id server_change_id) {
     changes_.clear();
     bool result = false;
     view_manager_->AddNode(parent, child, server_change_id,
                            base::Bind(&ViewManagerProxy::GotResult,
                                       base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
-  bool RemoveNodeFromParent(TransportNodeId node_id,
-                            TransportChangeId server_change_id) {
+  bool RemoveNodeFromParent(Id node_id, Id server_change_id) {
     changes_.clear();
     bool result = false;
     view_manager_->RemoveNodeFromParent(node_id, server_change_id,
         base::Bind(&ViewManagerProxy::GotResult,
                    base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
-  bool SetView(TransportNodeId node_id, TransportViewId view_id) {
+  bool SetView(Id node_id, Id view_id) {
     changes_.clear();
     bool result = false;
     view_manager_->SetView(node_id, view_id,
                            base::Bind(&ViewManagerProxy::GotResult,
                                       base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
-  bool CreateView(TransportViewId view_id) {
+  bool CreateView(Id view_id) {
     changes_.clear();
     bool result = false;
     view_manager_->CreateView(view_id,
                               base::Bind(&ViewManagerProxy::GotResult,
                                          base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
-  void GetNodeTree(TransportNodeId node_id, std::vector<TestNode>* nodes) {
+  void GetNodeTree(Id node_id, std::vector<TestNode>* nodes) {
     changes_.clear();
     view_manager_->GetNodeTree(node_id,
                                base::Bind(&ViewManagerProxy::GotNodeTree,
                                           base::Unretained(this), nodes));
     RunMainLoop();
   }
-  bool Connect(const std::vector<TransportNodeId>& nodes) {
+  bool Connect(const std::vector<Id>& nodes) {
     changes_.clear();
     base::AutoReset<bool> auto_reset(&in_connect_, true);
     bool result = false;
-    view_manager_->Connect(kTestServiceURL, Array<TransportNodeId>::From(nodes),
+    view_manager_->Connect(kTestServiceURL, Array<Id>::From(nodes),
                            base::Bind(&ViewManagerProxy::GotResult,
                                       base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
-  bool DeleteNode(TransportNodeId node_id) {
+  bool DeleteNode(Id node_id) {
     changes_.clear();
     bool result = false;
     view_manager_->DeleteNode(node_id,
                               base::Bind(&ViewManagerProxy::GotResult,
                                          base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
-  bool DeleteView(TransportViewId view_id) {
+  bool DeleteView(Id view_id) {
     changes_.clear();
     bool result = false;
     view_manager_->DeleteView(view_id,
                               base::Bind(&ViewManagerProxy::GotResult,
                                          base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
-  bool SetNodeBounds(TransportNodeId node_id, const gfx::Rect& bounds) {
+  bool SetNodeBounds(Id node_id, const gfx::Rect& bounds) {
     changes_.clear();
     bool result = false;
     view_manager_->SetNodeBounds(node_id, Rect::From(bounds),
                                  base::Bind(&ViewManagerProxy::GotResult,
                                             base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
 
  private:
@@ skipping 92 matching lines @@
   }
 
   // InterfaceImp:
   virtual void OnConnectionEstablished() OVERRIDE {
     connection_.set_router(internal_state()->router());
     connection_.set_view_manager(client());
   }
 
   // IViewMangerClient:
   virtual void OnViewManagerConnectionEstablished(
-      TransportConnectionId connection_id,
-      TransportChangeId next_server_change_id,
+      ConnectionSpecificId connection_id,
+      Id next_server_change_id,
       Array<INodePtr> nodes) OVERRIDE {
     tracker_.OnViewManagerConnectionEstablished(
         connection_id, next_server_change_id, nodes.Pass());
   }
   virtual void OnRootsAdded(Array<INodePtr> nodes) OVERRIDE {
     tracker_.OnRootsAdded(nodes.Pass());
   }
   virtual void OnServerChangeIdAdvanced(
-      TransportChangeId next_server_change_id) OVERRIDE {
+      Id next_server_change_id) OVERRIDE {
     tracker_.OnServerChangeIdAdvanced(next_server_change_id);
   }
-  virtual void OnNodeBoundsChanged(TransportNodeId node_id,
+  virtual void OnNodeBoundsChanged(Id node_id,
                                    RectPtr old_bounds,
                                    RectPtr new_bounds) OVERRIDE {
     tracker_.OnNodeBoundsChanged(node_id, old_bounds.Pass(), new_bounds.Pass());
   }
-  virtual void OnNodeHierarchyChanged(
-      TransportNodeId node,
-      TransportNodeId new_parent,
-      TransportNodeId old_parent,
-      TransportChangeId server_change_id,
-      Array<INodePtr> nodes) OVERRIDE {
+  virtual void OnNodeHierarchyChanged(Id node,
+                                      Id new_parent,
+                                      Id old_parent,
+                                      Id server_change_id,
+                                      Array<INodePtr> nodes) OVERRIDE {
     tracker_.OnNodeHierarchyChanged(node, new_parent, old_parent,
                                     server_change_id, nodes.Pass());
   }
-  virtual void OnNodeDeleted(TransportNodeId node,
-                             TransportChangeId server_change_id) OVERRIDE {
+  virtual void OnNodeDeleted(Id node, Id server_change_id) OVERRIDE {
     tracker_.OnNodeDeleted(node, server_change_id);
   }
-  virtual void OnViewDeleted(TransportViewId view) OVERRIDE {
+  virtual void OnViewDeleted(Id view) OVERRIDE {
     tracker_.OnViewDeleted(view);
   }
-  virtual void OnNodeViewReplaced(TransportNodeId node,
-                                  TransportViewId new_view_id,
-                                  TransportViewId old_view_id) OVERRIDE {
+  virtual void OnNodeViewReplaced(Id node,
+                                  Id new_view_id,
+                                  Id old_view_id) OVERRIDE {
     tracker_.OnNodeViewReplaced(node, new_view_id, old_view_id);
   }
-  virtual void OnViewInputEvent(TransportViewId view_id,
+  virtual void OnViewInputEvent(Id view_id,
                                 EventPtr event,
                                 const Callback<void()>& callback) OVERRIDE {
     tracker_.OnViewInputEvent(view_id, event.Pass());
   }
 
  private:
   TestChangeTracker tracker_;
   ViewManagerProxy connection_;
 
   DISALLOW_COPY_AND_ASSIGN(TestViewManagerClientConnection);
@@ skipping 18 matching lines @@
                               const GURL& url) OVERRIDE {
   }
 
  private:
   ScopedVector<Application> apps_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectServiceLoader);
 };
 
 // Creates an id used for transport from the specified parameters.
-TransportNodeId BuildNodeId(TransportConnectionId connection_id,
-                            TransportConnectionSpecificNodeId node_id) {
+Id BuildNodeId(ConnectionSpecificId connection_id,
+               ConnectionSpecificId node_id) {
   return (connection_id << 16) | node_id;
 }
 
 // Creates an id used for transport from the specified parameters.
-TransportViewId BuildViewId(TransportConnectionId connection_id,
-                            TransportConnectionSpecificViewId view_id) {
+Id BuildViewId(ConnectionSpecificId connection_id,
+               ConnectionSpecificId view_id) {
   return (connection_id << 16) | view_id;
 }
 
 // Callback from ViewManagerInitConnect(). |result| is the result of the
 // Connect() call and |run_loop| the nested RunLoop.
 void ViewManagerInitConnectCallback(bool* result_cache,
                                     base::RunLoop* run_loop,
                                     bool result) {
   *result_cache = result;
   run_loop->Quit();
@@ skipping 39 matching lines @@
   }
 
   virtual void TearDown() OVERRIDE {
     if (connection2_)
       connection2_->Destroy();
     if (connection_)
       connection_->Destroy();
   }
 
  protected:
-  void EstablishSecondConnectionWithRoots(
-      TransportNodeId id1,
-      TransportNodeId id2) {
-    std::vector<TransportNodeId> node_ids;
+  void EstablishSecondConnectionWithRoots(Id id1, Id id2) {
+    std::vector<Id> node_ids;
     node_ids.push_back(id1);
     if (id2 != 0)
       node_ids.push_back(id2);
     ASSERT_TRUE(connection_->Connect(node_ids));
     connection2_ = ViewManagerProxy::WaitForInstance();
     ASSERT_TRUE(connection2_ != NULL);
     connection2_->DoRunLoopUntilChangesCount(1);
     ASSERT_EQ(1u, connection2_->changes().size());
   }
 
@@ skipping 31 matching lines @@
 // Verifies client gets a valid id.
 TEST_F(ViewManagerConnectionTest, ValidId) {
   EXPECT_EQ("OnConnectionEstablished",
             ChangesToDescription1(connection_->changes())[0]);
 
   // All these tests assume 1 for the client id. The only real assertion here is
   // the client id is not zero, but adding this as rest of code here assumes 1.
   EXPECT_EQ(1, connection_->changes()[0].connection_id);
 
   // Change ids start at 1 as well.
-  EXPECT_EQ(static_cast<TransportChangeId>(1),
-            connection_->changes()[0].change_id);
+  EXPECT_EQ(static_cast<Id>(1), connection_->changes()[0].change_id);
 }
 
 // Verifies two clients/connections get different ids.
 TEST_F(ViewManagerConnectionTest, TwoClientsGetDifferentConnectionIds) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   EXPECT_EQ("OnConnectionEstablished",
             ChangesToDescription1(connection2_->changes())[0]);
 
   // It isn't strickly necessary that the second connection gets 2, but these
   // tests are written assuming that is the case. The key thing is the
   // connection ids of |connection_| and |connection2_| differ.
   EXPECT_EQ(2, connection2_->changes()[0].connection_id);
 
   // Change ids start at 1 as well.
-  EXPECT_EQ(static_cast<TransportChangeId>(1),
-            connection2_->changes()[0].change_id);
+  EXPECT_EQ(static_cast<Id>(1), connection2_->changes()[0].change_id);
 }
 
 // Verifies client gets a valid id.
 TEST_F(ViewManagerConnectionTest, CreateNode) {
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
   EXPECT_TRUE(connection_->changes().empty());
 
   // Can't create a node with the same id.
   ASSERT_FALSE(connection_->CreateNode(BuildNodeId(1, 1)));
   EXPECT_TRUE(connection_->changes().empty());
@@ skipping 694 matching lines @@
 }
 
 TEST_F(ViewManagerConnectionTest, ConnectTwice) {
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Try to connect again to 1,1, this should fail as already connected to that
   // root.
   {
-    std::vector<TransportNodeId> node_ids;
+    std::vector<Id> node_ids;
     node_ids.push_back(BuildNodeId(1, 1));
     ASSERT_FALSE(connection_->Connect(node_ids));
   }
 
   // Connecting to 1,2 should succeed and end up in connection2.
   {
-    std::vector<TransportNodeId> node_ids;
+    std::vector<Id> node_ids;
     node_ids.push_back(BuildNodeId(1, 2));
     ASSERT_TRUE(connection_->Connect(node_ids));
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ("OnRootsAdded", changes[0]);
     EXPECT_EQ("[node=1,2 parent=null view=null]",
               ChangeNodeDescription(connection2_->changes()));
   }
 }
 
 // TODO(sky): add coverage of test that destroys connections and ensures other
 // connections get deletion notification (or advanced server id).
 
 // TODO(sky): need to better track changes to initial connection. For example,
 // that SetBounsdNodes/AddNode and the like don't result in messages to the
 // originating connection.
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo