Remove shell::Connection* parameter to InterfaceFactory<T>::Create()

services/ui/service.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 "services/ui/service.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 51 matching lines @@
 namespace {
 
 const char kResourceFileStrings[] = "mus_app_resources_strings.pak";
 const char kResourceFile100[] = "mus_app_resources_100.pak";
 const char kResourceFile200[] = "mus_app_resources_200.pak";
 
 }  // namespace
 
 // TODO(sky): this is a pretty typical pattern, make it easier to do.
 struct Service::PendingRequest {
-  shell::Connection* connection;
+  shell::Identity remote_identity;
   std::unique_ptr<mojom::WindowTreeFactoryRequest> wtf_request;
   std::unique_ptr<mojom::DisplayManagerRequest> dm_request;
 };
 
 struct Service::UserState {
   std::unique_ptr<ws::AccessibilityManager> accessibility;
   std::unique_ptr<ws::WindowTreeHostFactory> window_tree_host_factory;
 };
 
 Service::Service()
@@ skipping 39 matching lines @@
   ui::ResourceBundle::InitSharedInstanceWithPakFileRegion(
       loader.TakeFile(kResourceFileStrings),
       base::MemoryMappedFile::Region::kWholeFile);
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   rb.AddDataPackFromFile(loader.TakeFile(kResourceFile100),
                          ui::SCALE_FACTOR_100P);
   rb.AddDataPackFromFile(loader.TakeFile(kResourceFile200),
                          ui::SCALE_FACTOR_200P);
 }
 
-Service::UserState* Service::GetUserState(shell::Connection* connection) {
-  const ws::UserId& user_id = connection->GetRemoteIdentity().user_id();
+Service::UserState* Service::GetUserState(
+    const shell::Identity& remote_identity) {
+  const ws::UserId& user_id = remote_identity.user_id();
   auto it = user_id_to_user_state_.find(user_id);
   if (it != user_id_to_user_state_.end())
     return it->second.get();
   user_id_to_user_state_[user_id] = base::WrapUnique(new UserState);
   return user_id_to_user_state_[user_id].get();
 }
 
-void Service::AddUserIfNecessary(shell::Connection* connection) {
-  window_server_->user_id_tracker()->AddUserId(
-      connection->GetRemoteIdentity().user_id());
+void Service::AddUserIfNecessary(const shell::Identity& remote_identity) {
+  window_server_->user_id_tracker()->AddUserId(remote_identity.user_id());
 }
 
 void Service::OnStart(shell::Connector* connector,
                       const shell::Identity& identity,
                       uint32_t id) {
   platform_display_init_params_.surfaces_state = new SurfacesState;
 
   base::PlatformThread::SetName("mus");
   tracing_.Initialize(connector, identity.name());
   TRACE_EVENT0("mus", "Service::Initialize started");
@@ skipping 98 matching lines @@
 #endif
 
   return true;
 }
 
 void Service::OnFirstDisplayReady() {
   PendingRequests requests;
   requests.swap(pending_requests_);
   for (auto& request : requests) {
     if (request->wtf_request)
-      Create(request->connection, std::move(*request->wtf_request));
+      Create(request->remote_identity, std::move(*request->wtf_request));
     else
-      Create(request->connection, std::move(*request->dm_request));
+      Create(request->remote_identity, std::move(*request->dm_request));
   }
 }
 
 void Service::OnNoMoreDisplays() {
   // We may get here from the destructor, in which case there is no messageloop.
   if (base::MessageLoop::current())
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
 bool Service::IsTestConfig() const {
   return test_config_;
 }
 
 void Service::CreateDefaultDisplays() {
   // An asynchronous callback will create the Displays once the physical
   // displays are ready.
   platform_screen_->ConfigurePhysicalDisplay(base::Bind(
       &Service::OnCreatedPhysicalDisplay, weak_ptr_factory_.GetWeakPtr()));
 }
 
-void Service::Create(shell::Connection* connection,
+void Service::Create(const shell::Identity& remote_identity,
                      mojom::AccessibilityManagerRequest request) {
-  UserState* user_state = GetUserState(connection);
+  UserState* user_state = GetUserState(remote_identity);
   if (!user_state->accessibility) {
-    const ws::UserId& user_id = connection->GetRemoteIdentity().user_id();
+    const ws::UserId& user_id = remote_identity.user_id();
     user_state->accessibility.reset(
         new ws::AccessibilityManager(window_server_.get(), user_id));
   }
   user_state->accessibility->Bind(std::move(request));
 }
 
-void Service::Create(shell::Connection* connection,
+void Service::Create(const shell::Identity& remote_identity,
                      mojom::ClipboardRequest request) {
-  const ws::UserId& user_id = connection->GetRemoteIdentity().user_id();
+  const ws::UserId& user_id = remote_identity.user_id();
   window_server_->GetClipboardForUser(user_id)->AddBinding(std::move(request));
 }
 
-void Service::Create(shell::Connection* connection,
+void Service::Create(const shell::Identity& remote_identity,
                      mojom::DisplayManagerRequest request) {
   // DisplayManagerObservers generally expect there to be at least one display.
   if (!window_server_->display_manager()->has_displays()) {
     std::unique_ptr<PendingRequest> pending_request(new PendingRequest);
-    pending_request->connection = connection;
+    pending_request->remote_identity = remote_identity;
     pending_request->dm_request.reset(
         new mojom::DisplayManagerRequest(std::move(request)));
     pending_requests_.push_back(std::move(pending_request));
     return;
   }
   window_server_->display_manager()
-      ->GetUserDisplayManager(connection->GetRemoteIdentity().user_id())
+      ->GetUserDisplayManager(remote_identity.user_id())
       ->AddDisplayManagerBinding(std::move(request));
 }
 
-void Service::Create(shell::Connection* connection, mojom::GpuRequest request) {
+void Service::Create(const shell::Identity& remote_identity,
+                     mojom::GpuRequest request) {
   if (use_chrome_gpu_command_buffer_)
     return;
   DCHECK(platform_display_init_params_.gpu_state);
   new GpuImpl(std::move(request), platform_display_init_params_.gpu_state);
 }
 
-void Service::Create(shell::Connection* connection,
+void Service::Create(const shell::Identity& remote_identity,
                      mojom::GpuServiceRequest request) {
   if (!use_chrome_gpu_command_buffer_)
     return;
-  new GpuServiceImpl(std::move(request), connection);
+  new GpuServiceImpl(std::move(request));
 }
 
-void Service::Create(shell::Connection* connection,
+void Service::Create(const shell::Identity& remote_identity,
                      mojom::UserAccessManagerRequest request) {
   window_server_->user_id_tracker()->Bind(std::move(request));
 }
 
-void Service::Create(shell::Connection* connection,
+void Service::Create(const shell::Identity& remote_identity,
                      mojom::UserActivityMonitorRequest request) {
-  AddUserIfNecessary(connection);
-  const ws::UserId& user_id = connection->GetRemoteIdentity().user_id();
+  AddUserIfNecessary(remote_identity);
+  const ws::UserId& user_id = remote_identity.user_id();
   window_server_->GetUserActivityMonitorForUser(user_id)->Add(
       std::move(request));
 }
 
-void Service::Create(shell::Connection* connection,
+void Service::Create(const shell::Identity& remote_identity,
                      mojom::WindowManagerWindowTreeFactoryRequest request) {
-  AddUserIfNecessary(connection);
+  AddUserIfNecessary(remote_identity);
   window_server_->window_manager_window_tree_factory_set()->Add(
-      connection->GetRemoteIdentity().user_id(), std::move(request));
+    remote_identity.user_id(), std::move(request));
 }
 
-void Service::Create(Connection* connection,
+void Service::Create(const shell::Identity& remote_identity,
                      mojom::WindowTreeFactoryRequest request) {
-  AddUserIfNecessary(connection);
+  AddUserIfNecessary(remote_identity);
   if (!window_server_->display_manager()->has_displays()) {
     std::unique_ptr<PendingRequest> pending_request(new PendingRequest);
-    pending_request->connection = connection;
+    pending_request->remote_identity = remote_identity;
     pending_request->wtf_request.reset(
         new mojom::WindowTreeFactoryRequest(std::move(request)));
     pending_requests_.push_back(std::move(pending_request));
     return;
   }
-  AddUserIfNecessary(connection);
-  new ws::WindowTreeFactory(
-      window_server_.get(), connection->GetRemoteIdentity().user_id(),
-      connection->GetRemoteIdentity().name(), std::move(request));
+  AddUserIfNecessary(remote_identity);
+  new ws::WindowTreeFactory(window_server_.get(), remote_identity.user_id(),
+                            remote_identity.name(), std::move(request));
 }
 
-void Service::Create(Connection* connection,
+void Service::Create(const shell::Identity& remote_identity,
                      mojom::WindowTreeHostFactoryRequest request) {
-  UserState* user_state = GetUserState(connection);
+  UserState* user_state = GetUserState(remote_identity);
   if (!user_state->window_tree_host_factory) {
     user_state->window_tree_host_factory.reset(new ws::WindowTreeHostFactory(
-        window_server_.get(), connection->GetRemoteIdentity().user_id(),
+        window_server_.get(), remote_identity.user_id(),
         platform_display_init_params_));
   }
   user_state->window_tree_host_factory->AddBinding(std::move(request));
 }
 
-void Service::Create(Connection* connection,
+void Service::Create(const shell::Identity& remote_identity,
                      mojom::WindowServerTestRequest request) {
   if (!test_config_)
     return;
   new ws::WindowServerTestImpl(window_server_.get(), std::move(request));
 }
 
 void Service::OnCreatedPhysicalDisplay(int64_t id, const gfx::Rect& bounds) {
   platform_display_init_params_.display_bounds = bounds;
   platform_display_init_params_.display_id = id;
 
   // Display manages its own lifetime.
   ws::Display* host_impl =
       new ws::Display(window_server_.get(), platform_display_init_params_);
   host_impl->Init(nullptr);
 
   if (touch_controller_)
     touch_controller_->UpdateTouchTransforms();
 }
 
 }  // namespace ui