Rename shell namespace to service_manager

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 35 matching lines @@
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include "ui/platform_window/x11/x11_window.h"
 #elif defined(USE_OZONE)
 #include "ui/events/ozone/layout/keyboard_layout_engine.h"
 #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
-using shell::Connection;
+using service_manager::Connection;
 using mojo::InterfaceRequest;
 using ui::mojom::WindowServerTest;
 using ui::mojom::WindowTreeHostFactory;
 
 namespace ui {
 
 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::Identity remote_identity;
+  service_manager::Identity remote_identity;
   std::unique_ptr<mojom::WindowTreeFactoryRequest> wtf_request;
   std::unique_ptr<mojom::DisplayManagerRequest> dm_request;
 };
 
 struct Service::UserState {
   std::unique_ptr<clipboard::ClipboardImpl> clipboard;
   std::unique_ptr<ws::AccessibilityManager> accessibility;
   std::unique_ptr<ws::WindowTreeHostFactory> window_tree_host_factory;
 };
 
 Service::Service()
     : test_config_(false),
       platform_screen_(display::PlatformScreen::Create()),
       ime_registrar_(&ime_server_) {}
 
 Service::~Service() {
   // Destroy |window_server_| first, since it depends on |event_source_|.
   // WindowServer (or more correctly its Displays) may have state that needs to
   // be destroyed before GpuState as well.
   window_server_.reset();
 }
 
-void Service::InitializeResources(shell::Connector* connector) {
+void Service::InitializeResources(service_manager::Connector* connector) {
   if (ui::ResourceBundle::HasSharedInstance())
     return;
 
   std::set<std::string> resource_paths;
   resource_paths.insert(kResourceFileStrings);
   resource_paths.insert(kResourceFile100);
   resource_paths.insert(kResourceFile200);
 
   catalog::ResourceLoader loader;
   filesystem::mojom::DirectoryPtr directory;
   connector->ConnectToInterface("service:catalog", &directory);
   CHECK(loader.OpenFiles(std::move(directory), resource_paths));
 
   ui::RegisterPathProvider();
 
   // Initialize resource bundle with 1x and 2x cursor bitmaps.
   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(
-    const shell::Identity& remote_identity) {
+    const service_manager::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(const shell::Identity& remote_identity) {
+void Service::AddUserIfNecessary(
+    const service_manager::Identity& remote_identity) {
   window_server_->user_id_tracker()->AddUserId(remote_identity.user_id());
 }
 
-void Service::OnStart(const shell::Identity& identity) {
+void Service::OnStart(const service_manager::Identity& identity) {
   base::PlatformThread::SetName("mus");
   tracing_.Initialize(connector(), identity.name());
   TRACE_EVENT0("mus", "Service::Initialize started");
 
   test_config_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUseTestConfig);
 #if defined(USE_X11)
   XInitThreads();
   if (test_config_)
     ui::test::SetUseOverrideRedirectWindowByDefault(true);
@@ skipping 38 matching lines @@
 
   // DeviceDataManager must be initialized before TouchController. On non-Linux
   // platforms there is no DeviceDataManager so don't create touch controller.
   if (ui::DeviceDataManager::HasInstance())
     touch_controller_.reset(
         new ws::TouchController(window_server_->display_manager()));
 
   ime_server_.Init(connector());
 }
 
-bool Service::OnConnect(const shell::Identity& remote_identity,
-                        shell::InterfaceRegistry* registry) {
+bool Service::OnConnect(const service_manager::Identity& remote_identity,
+                        service_manager::InterfaceRegistry* registry) {
   registry->AddInterface<mojom::AccessibilityManager>(this);
   registry->AddInterface<mojom::Clipboard>(this);
   registry->AddInterface<mojom::DisplayManager>(this);
   registry->AddInterface<mojom::GpuService>(this);
   registry->AddInterface<mojom::IMERegistrar>(this);
   registry->AddInterface<mojom::IMEServer>(this);
   registry->AddInterface<mojom::UserAccessManager>(this);
   registry->AddInterface<mojom::UserActivityMonitor>(this);
   registry->AddInterface<WindowTreeHostFactory>(this);
   registry->AddInterface<mojom::WindowManagerWindowTreeFactory>(this);
@@ skipping 42 matching lines @@
   if (touch_controller_)
     touch_controller_->UpdateTouchTransforms();
 }
 
 void Service::CreateDefaultDisplays() {
   // The display manager will create Displays once hardware or virtual displays
   // are ready.
   platform_screen_->Init(window_server_->display_manager());
 }
 
-void Service::Create(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::Identity& remote_identity,
                      mojom::AccessibilityManagerRequest request) {
   UserState* user_state = GetUserState(remote_identity);
   if (!user_state->accessibility) {
     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(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::Identity& remote_identity,
                      mojom::ClipboardRequest request) {
   UserState* user_state = GetUserState(remote_identity);
   if (!user_state->clipboard)
     user_state->clipboard.reset(new clipboard::ClipboardImpl);
   user_state->clipboard->AddBinding(std::move(request));
 }
 
-void Service::Create(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::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->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(remote_identity.user_id())
       ->AddDisplayManagerBinding(std::move(request));
 }
 
-void Service::Create(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::Identity& remote_identity,
                      mojom::GpuServiceRequest request) {
   window_server_->gpu_proxy()->Add(std::move(request));
 }
 
-void Service::Create(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::Identity& remote_identity,
                      mojom::IMERegistrarRequest request) {
   ime_registrar_.AddBinding(std::move(request));
 }
 
-void Service::Create(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::Identity& remote_identity,
                      mojom::IMEServerRequest request) {
   ime_server_.AddBinding(std::move(request));
 }
 
-void Service::Create(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::Identity& remote_identity,
                      mojom::UserAccessManagerRequest request) {
   window_server_->user_id_tracker()->Bind(std::move(request));
 }
 
-void Service::Create(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::Identity& remote_identity,
                      mojom::UserActivityMonitorRequest request) {
   AddUserIfNecessary(remote_identity);
   const ws::UserId& user_id = remote_identity.user_id();
   window_server_->GetUserActivityMonitorForUser(user_id)->Add(
       std::move(request));
 }
 
-void Service::Create(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::Identity& remote_identity,
                      mojom::WindowManagerWindowTreeFactoryRequest request) {
   AddUserIfNecessary(remote_identity);
   window_server_->window_manager_window_tree_factory_set()->Add(
     remote_identity.user_id(), std::move(request));
 }
 
-void Service::Create(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::Identity& remote_identity,
                      mojom::WindowTreeFactoryRequest request) {
   AddUserIfNecessary(remote_identity);
   if (!window_server_->display_manager()->has_displays()) {
     std::unique_ptr<PendingRequest> pending_request(new PendingRequest);
     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(remote_identity);
   mojo::MakeStrongBinding(base::MakeUnique<ws::WindowTreeFactory>(
                               window_server_.get(), remote_identity.user_id(),
                               remote_identity.name()),
                           std::move(request));
 }
 
-void Service::Create(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::Identity& remote_identity,
                      mojom::WindowTreeHostFactoryRequest request) {
   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(), remote_identity.user_id()));
   }
   user_state->window_tree_host_factory->AddBinding(std::move(request));
 }
 
-void Service::Create(const shell::Identity& remote_identity,
+void Service::Create(const service_manager::Identity& remote_identity,
                      mojom::WindowServerTestRequest request) {
   if (!test_config_)
     return;
   mojo::MakeStrongBinding(
       base::MakeUnique<ws::WindowServerTestImpl>(window_server_.get()),
       std::move(request));
 }
 
 
 }  // namespace ui