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

mojo/shell/tests/lifecycle/lifecycle_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 "base/base_paths.h"
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/process/process.h"
 #include "base/run_loop.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
+#include "mojo/shell/public/cpp/identity.h"
 #include "mojo/shell/public/cpp/shell_test.h"
 #include "mojo/shell/public/interfaces/shell.mojom.h"
 #include "mojo/shell/runner/common/switches.h"
 #include "mojo/shell/tests/lifecycle/lifecycle_unittest.mojom.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
 const char kTestAppName[] = "mojo:lifecycle_unittest_app";
 const char kTestExeName[] = "exe:lifecycle_unittest_exe";
 const char kTestPackageName[] = "mojo:lifecycle_unittest_package";
 const char kTestPackageAppNameA[] = "mojo:lifecycle_unittest_package_app_a";
 const char kTestPackageAppNameB[] = "mojo:lifecycle_unittest_package_app_b";
 const char kTestName[] = "mojo:lifecycle_unittest";
 
 void QuitLoop(base::RunLoop* loop) {
   loop->Quit();
 }
 
 void DecrementCountAndQuitWhenZero(base::RunLoop* loop, size_t* count) {
   if (!--(*count))
     loop->Quit();
 }
 
 struct Instance {
   Instance() : id(shell::mojom::kInvalidInstanceID), pid(0) {}
-  Instance(const std::string& name, const std::string& qualifier, uint32_t id,
-           uint32_t pid)
-      : name(name), qualifier(qualifier), id(id), pid(pid) {}
+  Instance(const Identity& identity, uint32_t id, uint32_t pid)
+      : identity(identity), id(id), pid(pid) {}
 
-  std::string name;
-  std::string qualifier;
+  Identity identity;
   uint32_t id;
   uint32_t pid;
 };
 
 class InstanceState : public mojom::InstanceListener {
  public:
   InstanceState(mojom::InstanceListenerRequest request, base::RunLoop* loop)
       : binding_(this, std::move(request)), loop_(loop) {}
   ~InstanceState() override {}
 
   bool HasInstanceForName(const std::string& name) const {
     return instances_.find(name) != instances_.end();
   }
   size_t GetNewInstanceCount() const {
     return instances_.size() - initial_instances_.size();
   }
   void WaitForInstanceDestruction(base::RunLoop* loop) {
     DCHECK(!destruction_loop_);
     destruction_loop_ = loop;
     // First of all check to see if we should be spinning this loop at all -
     // the app(s) we're waiting on quitting may already have quit.
     TryToQuitDestructionLoop();
   }
 
  private:
   // mojom::InstanceListener:
   void SetExistingInstances(Array<mojom::InstanceInfoPtr> instances) override {
     for (const auto& instance : instances) {
-      Instance i(instance->name, instance->qualifier, instance->id,
+      Instance i(instance->identity.To<Identity>(), instance->id,
                  instance->pid);
-      initial_instances_[i.name] = i;
-      instances_[i.name] = i;
+      initial_instances_[i.identity.name()] = i;
+      instances_[i.identity.name()] = i;
     }
     loop_->Quit();
   }
   void InstanceCreated(mojom::InstanceInfoPtr instance) override {
-    instances_[instance->name] =
-       Instance(instance->name, instance->qualifier, instance->id,
-                instance->pid);
+    instances_[instance->identity->name] =
+        Instance(instance->identity.To<Identity>(), instance->id,
+                 instance->pid);
   }
   void InstanceDestroyed(uint32_t id) override {
     for (auto it = instances_.begin(); it != instances_.end(); ++it) {
       if (it->second.id == id) {
         instances_.erase(it);
         break;
       }
     }
     TryToQuitDestructionLoop();
   }
@@ skipping 112 matching lines @@
     test_interfaces.push_back("*");
     filter->filter.insert("*", std::move(test_interfaces));
 
     mojo::shell::mojom::ShellPtr shell;
     connector()->ConnectToInterface("mojo:shell", &shell);
 
     mojo::shell::mojom::ShellClientFactoryPtr factory;
     factory.Bind(mojo::InterfacePtrInfo<mojo::shell::mojom::ShellClientFactory>(
         std::move(pipe), 0u));
     base::RunLoop loop;
-    shell->CreateInstance(std::move(factory), kTestExeName,
-                          mojom::kInheritUserID, std::move(filter),
-                          std::move(request),
+    mojo::shell::mojom::IdentityPtr target(mojo::shell::mojom::Identity::New());
+    target->name = kTestExeName;
+    target->user_id = mojom::kInheritUserID;
+    target->instance = "";
+    shell->CreateInstance(std::move(factory), std::move(target),
+                          std::move(filter), std::move(request),
                           base::Bind(&LifecycleTest::OnConnectionCompleted,
                                      base::Unretained(this), &loop));
     loop.Run();
 
     base::LaunchOptions options;
   #if defined(OS_WIN)
     options.handles_to_inherit = &handle_passing_info;
   #elif defined(OS_POSIX)
     options.fds_to_remap = &handle_passing_info;
   #endif
@@ skipping 273 matching lines @@
   loop.Run();
 
   WaitForInstanceDestruction();
   EXPECT_FALSE(instances()->HasInstanceForName(kTestExeName));
   EXPECT_EQ(0u, instances()->GetNewInstanceCount());
 }
 
 
 }  // namespace shell
 }  // namespace mojo