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

components/mus/mus_app.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 "components/mus/mus_app.h"
 
 #include <set>
 
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
@@ skipping 78 matching lines @@
   ui::ResourceBundle::InitSharedInstanceWithPakFileRegion(
       resource_loader.ReleaseFile(kResourceFileStrings),
       base::MemoryMappedFile::Region::kWholeFile);
   ui::ResourceBundle::GetSharedInstance().AddDataPackFromFile(
       resource_loader.ReleaseFile(kResourceFile100), ui::SCALE_FACTOR_100P);
   ui::ResourceBundle::GetSharedInstance().AddDataPackFromFile(
       resource_loader.ReleaseFile(kResourceFile200), ui::SCALE_FACTOR_200P);
 }
 
 void MandolineUIServicesApp::Initialize(mojo::Connector* connector,
-                                        const std::string& url,
-                                        const std::string& user_id,
+                                        const mojo::Identity& identity,
                                         uint32_t id) {
   connector_ = connector;
   surfaces_state_ = new SurfacesState;
 
   base::PlatformThread::SetName("mus");
 
 #if defined(USE_X11)
   XInitThreads();
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(kUseX11TestConfig)) {
@@ skipping 17 matching lines @@
 
 #if !defined(OS_ANDROID)
   event_source_ = ui::PlatformEventSource::CreateDefault();
 #endif
 
   // TODO(rjkroege): It is possible that we might want to generalize the
   // GpuState object.
   gpu_state_ = new GpuState();
   connection_manager_.reset(new ws::ConnectionManager(this, surfaces_state_));
 
-  tracing_.Initialize(connector, url);
+  tracing_.Initialize(connector, identity.name());
 }
 
 bool MandolineUIServicesApp::AcceptConnection(Connection* connection) {
   connection->AddInterface<Gpu>(this);
   connection->AddInterface<mojom::DisplayManager>(this);
   connection->AddInterface<mojom::WindowManagerFactoryService>(this);
   connection->AddInterface<mojom::WindowTreeFactory>(this);
   connection->AddInterface<WindowTreeHostFactory>(this);
   return true;
 }
@@ skipping 28 matching lines @@
   // Display manages its own lifetime.
   ws::Display* host_impl = new ws::Display(
       connection_manager_.get(), connector_, gpu_state_, surfaces_state_);
   host_impl->Init(nullptr);
 }
 
 void MandolineUIServicesApp::Create(mojo::Connection* connection,
                                     mojom::DisplayManagerRequest request) {
   // TODO(sky): validate id.
   connection_manager_->display_manager()
-      ->GetUserDisplayManager(connection->GetRemoteUserID())
+      ->GetUserDisplayManager(connection->GetRemoteIdentity().user_id())
       ->AddDisplayManagerBinding(std::move(request));
 }
 
 void MandolineUIServicesApp::Create(
     mojo::Connection* connection,
     mojom::WindowManagerFactoryServiceRequest request) {
   connection_manager_->window_manager_factory_registry()->Register(
-      connection->GetRemoteUserID(), std::move(request));
+      connection->GetRemoteIdentity().user_id(), std::move(request));
 }
 
 void MandolineUIServicesApp::Create(Connection* connection,
                                     mojom::WindowTreeFactoryRequest request) {
   if (!connection_manager_->display_manager()->has_displays()) {
     scoped_ptr<PendingRequest> pending_request(new PendingRequest);
     pending_request->wtf_request.reset(
         new mojo::InterfaceRequest<mojom::WindowTreeFactory>(
             std::move(request)));
     pending_requests_.push_back(std::move(pending_request));
@@ skipping 28 matching lines @@
   ws::Display* host_impl = new ws::Display(
       connection_manager_.get(), connector_, gpu_state_, surfaces_state_);
 
   scoped_ptr<ws::DisplayBindingImpl> display_binding(new ws::DisplayBindingImpl(
       std::move(host), host_impl, std::move(tree_client),
       connection_manager_.get()));
   host_impl->Init(std::move(display_binding));
 }
 
 }  // namespace mus