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

mojo/shell/tests/loader_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 <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 105 matching lines @@
   // Loader implementation.
   void Load(const std::string& name,
             mojom::ShellClientRequest request) override {
     ++num_loads_;
     shell_connection_.reset(new ShellConnection(this, std::move(request)));
   }
 
   // mojo::ShellClient implementation.
   bool AcceptConnection(Connection* connection) override {
     connection->AddInterface<TestService>(this);
-    last_requestor_name_ = connection->GetRemoteApplicationName();
+    last_requestor_name_ = connection->GetRemoteIdentity().name();
     return true;
   }
 
   // InterfaceFactory<TestService> implementation.
   void Create(Connection* connection,
               InterfaceRequest<TestService> request) override {
     new TestServiceImpl(context_, std::move(request));
   }
 
   scoped_ptr<ShellConnection> shell_connection_;
@@ skipping 209 matching lines @@
   ~Tester() override {}
 
  private:
   void Load(const std::string& name,
             InterfaceRequest<mojom::ShellClient> request) override {
     app_.reset(new ShellConnection(this, std::move(request)));
   }
 
   bool AcceptConnection(Connection* connection) override {
     if (!requestor_name_.empty() &&
-        requestor_name_ != connection->GetRemoteApplicationName()) {
+        requestor_name_ != connection->GetRemoteIdentity().name()) {
       context_->set_tester_called_quit();
       context_->QuitSoon();
       base::MessageLoop::current()->QuitWhenIdle();
       return false;
     }
     // If we're coming from A, then add B, otherwise A.
-    if (connection->GetRemoteApplicationName() == kTestAURLString)
+    if (connection->GetRemoteIdentity().name() == kTestAURLString)
       connection->AddInterface<TestB>(this);
     else
       connection->AddInterface<TestA>(this);
     return true;
   }
 
   void Create(Connection* connection,
               InterfaceRequest<TestA> request) override {
     a_bindings_.push_back(
         new TestAImpl(app_->connector(), context_, std::move(request), this));
@@ skipping 52 matching lines @@
   }
 
  protected:
   template <typename Interface>
   void ConnectToInterface(const std::string& name,
                           InterfacePtr<Interface>* ptr) {
     base::RunLoop loop;
     mojom::InterfaceProviderPtr remote_interfaces;
     scoped_ptr<ConnectParams> params(new ConnectParams);
     params->set_source(CreateShellIdentity());
-    params->set_target(Identity(name));
+    params->set_target(Identity(name, mojom::kRootUserID));
     params->set_remote_interfaces(GetProxy(&remote_interfaces));
     params->set_connect_callback(
         base::Bind(&OnConnect, base::Unretained(&loop)));
     shell_->Connect(std::move(params));
     loop.Run();
 
     mojo::GetInterface(remote_interfaces.get(), ptr);
   }
 
   base::ShadowingAtExitManager at_exit_;
@@ skipping 69 matching lines @@
   EXPECT_TRUE(c.encountered_error());
 }
 
 TEST_F(LoaderTest, TestEndApplicationClosure) {
   ClosingLoader* loader = new ClosingLoader();
   shell_->SetLoaderForName(scoped_ptr<Loader>(loader), "test:test");
 
   bool called = false;
   scoped_ptr<ConnectParams> params(new ConnectParams);
   params->set_source(CreateShellIdentity());
-  params->set_target(Identity("test:test", "", mojom::kRootUserID));
+  params->set_target(Identity("test:test", mojom::kRootUserID));
   shell_->SetInstanceQuitCallback(
       base::Bind(&QuitClosure, params->target(), &called));
   shell_->Connect(std::move(params));
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 TEST_F(LoaderTest, SameIdentityShouldNotCauseDuplicateLoad) {
   // 1 because LoaderTest connects once at startup.
   EXPECT_EQ(1, test_loader_->num_loads());
 
   TestServicePtr test_service;
   ConnectToInterface("test:foo", &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // Exactly the same name as above.
   ConnectToInterface("test:foo", &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // A different identity because the domain is different.
   ConnectToInterface("test:bar", &test_service);
   EXPECT_EQ(3, test_loader_->num_loads());
 }
 
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo