Add a instance groups to Connect(), and introduce an Identity struct.

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 31 matching lines @@
 }  // namespace
 
 class ConnectTest : public mojo::test::ShellTest,
                     public InterfaceFactory<test::mojom::ExposedInterface>,
                     public test::mojom::ExposedInterface {
  public:
   ConnectTest() : ShellTest("mojo:connect_unittests") {}
   ~ConnectTest() override {}
 
  protected:
+  scoped_ptr<Connection> ConnectTo(Connector::ConnectParams* params) {
+    scoped_ptr<Connection> connection = connector()->Connect(params);
+    base::RunLoop loop;
+    connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
+    loop.Run();
+    return connection;
+  }
+
   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,
       const std::string& connection_remote_userid,
       uint32_t connection_remote_id,
       const std::string& initialize_local_name,
@@ skipping 50 matching lines @@
   scoped_ptr<Connection> connection = connector()->Connect(kTestAppName);
   test::mojom::ConnectTestServicePtr service;
   connection->GetInterface(&service);
   base::RunLoop run_loop;
   std::string title;
   service->GetTitle(base::Bind(&ReceiveTitle, &title, &run_loop));
   run_loop.Run();
   EXPECT_EQ("APP", title);
   EXPECT_FALSE(connection->IsPending());
   EXPECT_NE(mojom::kInvalidInstanceID, connection->GetRemoteInstanceID());
-  EXPECT_EQ(connection->GetRemoteApplicationName(), kTestAppName);
+  EXPECT_EQ(connection->GetRemoteIdentity().name(), kTestAppName);
+}
+
+TEST_F(ConnectTest, Instances) {
+  Connector::ConnectParams params_a(
+      Identity(kTestAppName, mojom::kInheritUserID, "A"));
+  scoped_ptr<Connection> connection_a1 = ConnectTo(&params_a);
+  scoped_ptr<Connection> connection_a2 = ConnectTo(&params_a);
+  std::string instance_a1, instance_a2;
+  test::mojom::StandaloneAppPtr standalone_app_a1;
+  {
+    connection_a1->GetInterface(&standalone_app_a1);
+    base::RunLoop loop;
+    standalone_app_a1->GetInstance(
+        base::Bind(&ReceiveTitle, &instance_a1, &loop));
+    loop.Run();
+  }
+  test::mojom::StandaloneAppPtr standalone_app_a2;
+  {
+    connection_a2->GetInterface(&standalone_app_a2);
+    base::RunLoop loop;
+    standalone_app_a2->GetInstance(
+        base::Bind(&ReceiveTitle, &instance_a2, &loop));
+    loop.Run();
+  }
+  EXPECT_EQ(instance_a1, instance_a2);
+
+  Connector::ConnectParams params_b(
+      Identity(kTestAppName, mojom::kInheritUserID, "B"));
+  scoped_ptr<Connection> connection_b = ConnectTo(&params_b);
+  std::string instance_b;
+  test::mojom::StandaloneAppPtr standalone_app_b;
+  {
+    connection_b->GetInterface(&standalone_app_b);
+    base::RunLoop loop;
+    standalone_app_b->GetInstance(
+        base::Bind(&ReceiveTitle, &instance_b, &loop));
+    loop.Run();
+  }
+
+  EXPECT_NE(instance_a1, instance_b);
 }
 
 // BlockedInterface should not be exposed to this application because it is not
 // in our CapabilityFilter whitelist.
 TEST_F(ConnectTest, BlockedInterface) {
   scoped_ptr<Connection> connection = connector()->Connect(kTestAppName);
   base::RunLoop run_loop;
   test::mojom::BlockedInterfacePtr blocked;
   connection->GetInterface(&blocked);
   blocked.set_connection_error_handler(base::Bind(&QuitLoop, &run_loop));
   std::string title = "unchanged";
   blocked->GetTitleBlocked(base::Bind(&ReceiveTitle, &title, &run_loop));
   run_loop.Run();
   EXPECT_EQ("unchanged", title);
 }
 
 // Connects to an app provided by a package.
 TEST_F(ConnectTest, PackagedApp) {
   scoped_ptr<Connection> connection = connector()->Connect(kTestAppAName);
   test::mojom::ConnectTestServicePtr service_a;
   connection->GetInterface(&service_a);
   base::RunLoop run_loop;
   std::string a_name;
   service_a->GetTitle(base::Bind(&ReceiveTitle, &a_name, &run_loop));
   run_loop.Run();
   EXPECT_EQ("A", a_name);
   EXPECT_FALSE(connection->IsPending());
   EXPECT_NE(mojom::kInvalidInstanceID, connection->GetRemoteInstanceID());
-  EXPECT_EQ(connection->GetRemoteApplicationName(), kTestAppAName);
+  EXPECT_EQ(connection->GetRemoteIdentity().name(), kTestAppAName);
 }
 
 // Ask the target application to attempt to connect to a third application
 // provided by a package whose id is permitted by the primary target's
 // CapabilityFilter but whose package is not. The connection should be
 // blocked and the returned title should be "uninitialized".
 TEST_F(ConnectTest, BlockedPackage) {
   scoped_ptr<Connection> connection = connector()->Connect(kTestAppName);
   test::mojom::StandaloneAppPtr standalone_app;
   connection->GetInterface(&standalone_app);
@@ skipping 53 matching lines @@
       remote_id = connection->GetRemoteInstanceID();
       EXPECT_NE(mojom::kInvalidInstanceID, 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, connection->GetRemoteUserID(), remote_id);
+          kTestAppName, connection->GetRemoteIdentity().user_id(), 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 = shell::mojom::kInvalidInstanceID;
     {
       base::RunLoop run_loop;
       EXPECT_TRUE(connection->IsPending());
       EXPECT_EQ(mojom::kInvalidInstanceID, connection->GetRemoteInstanceID());
       connection->AddConnectionCompletedClosure(
           base::Bind(&QuitLoop, &run_loop));
       run_loop.Run();
       EXPECT_FALSE(connection->IsPending());
       remote_id = connection->GetRemoteInstanceID();
       EXPECT_NE(mojom::kInvalidInstanceID, 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, connection->GetRemoteUserID(), remote_id);
+          kTestAppAName, connection->GetRemoteIdentity().user_id(), remote_id);
     }
 
   }
 }
 
 }  // namespace shell
 }  // namespace mojo