Change userid from a uint32_t to a string guid

mojo/shell/tests/connect/connect_unittest.cc

 // Copyright 2016 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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 38 matching lines @@
   ~ConnectTest() override {}
 
  protected:
   void set_ping_callback(const base::Closure& callback) {
     ping_callback_ = callback;
   }
 
   void CompareConnectionState(
       const std::string& connection_local_name,
       const std::string& connection_remote_name,
-      uint32_t connection_remote_userid,
+      const std::string& connection_remote_userid,
       uint32_t connection_remote_id,
       const std::string& initialize_local_name,
-      uint32_t initialize_id,
-      uint32_t initialize_userid) {
+      const std::string& initialize_userid,
+      uint32_t initialize_id) {
     EXPECT_EQ(connection_local_name, connection_state_->connection_local_name);
     EXPECT_EQ(connection_remote_name,
               connection_state_->connection_remote_name);
     EXPECT_EQ(connection_remote_userid,
               connection_state_->connection_remote_userid);
     EXPECT_EQ(connection_remote_id, connection_state_->connection_remote_id);
     EXPECT_EQ(initialize_local_name, connection_state_->initialize_local_name);
     EXPECT_EQ(initialize_id, connection_state_->initialize_id);
     EXPECT_EQ(initialize_userid, connection_state_->initialize_userid);
   }
@@ skipping 142 matching lines @@
       EXPECT_TRUE(connection->GetRemoteApplicationID(&remote_id));
       EXPECT_NE(mojom::Connector::kInvalidApplicationID, remote_id);
     }
 
     {
       base::RunLoop run_loop;
       set_ping_callback(base::Bind(&QuitLoop, &run_loop));
       run_loop.Run();
       CompareConnectionState(
           kTestAppName, test_name(), test_userid(), test_instance_id(),
-          kTestAppName, remote_id, connection->GetRemoteUserID());
+          kTestAppName, connection->GetRemoteUserID(), remote_id);
     }
   }
 
   // Connect to an application provided by a package.
   {
     test::mojom::ConnectTestServicePtr service_a;
     scoped_ptr<Connection> connection = connector()->Connect(kTestAppAName);
     connection->GetInterface(&service_a);
     connection->AddInterface<test::mojom::ExposedInterface>(this);
 
     uint32_t remote_id = mojom::Connector::kInvalidApplicationID;
     {
       base::RunLoop run_loop;
       EXPECT_FALSE(connection->GetRemoteApplicationID(&remote_id));
       EXPECT_EQ(mojom::Connector::kInvalidApplicationID, remote_id);
       connection->AddRemoteIDCallback(base::Bind(&QuitLoop, &run_loop));
       run_loop.Run();
       EXPECT_TRUE(connection->GetRemoteApplicationID(&remote_id));
       EXPECT_NE(mojom::Connector::kInvalidApplicationID, remote_id);
     }
 
     {
       base::RunLoop run_loop;
       set_ping_callback(base::Bind(&QuitLoop, &run_loop));
       run_loop.Run();
       CompareConnectionState(
           kTestAppAName, test_name(), test_userid(), test_instance_id(),
-          kTestAppAName, remote_id, connection->GetRemoteUserID());
+          kTestAppAName, connection->GetRemoteUserID(), remote_id);
     }
 
   }
 }
 
 }  // namespace shell
 }  // namespace mojo