Move shell service to toplevel shell namespace

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 24 matching lines @@
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include "base/command_line.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 mojo::Connection;
+using shell::Connection;
 using mojo::InterfaceRequest;
 using mus::mojom::WindowTreeHostFactory;
 using mus::mojom::Gpu;
 
 namespace mus {
 
 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 MandolineUIServicesApp::PendingRequest {
-  mojo::Connection* connection;
+  shell::Connection* connection;
   scoped_ptr<mojo::InterfaceRequest<mojom::WindowTreeFactory>> wtf_request;
 };
 
 struct MandolineUIServicesApp::UserState {
   scoped_ptr<ws::WindowTreeFactory> window_tree_factory;
   scoped_ptr<ws::WindowTreeHostFactory> window_tree_host_factory;
 };
 
 MandolineUIServicesApp::MandolineUIServicesApp() {}
 
 MandolineUIServicesApp::~MandolineUIServicesApp() {
   // 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();
 
   if (platform_display_init_params_.gpu_state)
     platform_display_init_params_.gpu_state->StopThreads();
 }
 
-void MandolineUIServicesApp::InitializeResources(mojo::Connector* connector) {
+void MandolineUIServicesApp::InitializeResources(shell::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);
 
   resource_provider::ResourceLoader loader(connector, resource_paths);
   if (!loader.BlockUntilLoaded())
     return;
   ui::RegisterPathProvider();
 
   // Initialize resource bundle with 1x and 2x cursor bitmaps.
   ui::ResourceBundle::InitSharedInstanceWithPakFileRegion(
       loader.ReleaseFile(kResourceFileStrings),
       base::MemoryMappedFile::Region::kWholeFile);
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   rb.AddDataPackFromFile(loader.ReleaseFile(kResourceFile100),
                          ui::SCALE_FACTOR_100P);
   rb.AddDataPackFromFile(loader.ReleaseFile(kResourceFile200),
                          ui::SCALE_FACTOR_200P);
 }
 
 MandolineUIServicesApp::UserState* MandolineUIServicesApp::GetUserState(
-    mojo::Connection* connection) {
+    shell::Connection* connection) {
   const ws::UserId& user_id = connection->GetRemoteIdentity().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] = make_scoped_ptr(new UserState);
   return user_id_to_user_state_[user_id].get();
 }
 
-void MandolineUIServicesApp::AddUserIfNecessary(mojo::Connection* connection) {
+void MandolineUIServicesApp::AddUserIfNecessary(shell::Connection* connection) {
   window_server_->user_id_tracker()->AddUserId(
       connection->GetRemoteIdentity().user_id());
 }
 
-void MandolineUIServicesApp::Initialize(mojo::Connector* connector,
-                                        const mojo::Identity& identity,
+void MandolineUIServicesApp::Initialize(shell::Connector* connector,
+                                        const shell::Identity& identity,
                                         uint32_t id) {
   platform_display_init_params_.connector = connector;
   platform_display_init_params_.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 55 matching lines @@
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
 void MandolineUIServicesApp::CreateDefaultDisplays() {
   // Display manages its own lifetime.
   ws::Display* host_impl =
       new ws::Display(window_server_.get(), platform_display_init_params_);
   host_impl->Init(nullptr);
 }
 
-void MandolineUIServicesApp::Create(mojo::Connection* connection,
+void MandolineUIServicesApp::Create(shell::Connection* connection,
                                     mojom::DisplayManagerRequest request) {
   window_server_->display_manager()
       ->GetUserDisplayManager(connection->GetRemoteIdentity().user_id())
       ->AddDisplayManagerBinding(std::move(request));
 }
 
-void MandolineUIServicesApp::Create(mojo::Connection* connection,
+void MandolineUIServicesApp::Create(shell::Connection* connection,
                                     mojom::UserAccessManagerRequest request) {
   window_server_->user_id_tracker()->Bind(std::move(request));
 }
 
 void MandolineUIServicesApp::Create(
-    mojo::Connection* connection,
+    shell::Connection* connection,
     mojom::WindowManagerFactoryServiceRequest request) {
   AddUserIfNecessary(connection);
   window_server_->window_manager_factory_registry()->Register(
       connection->GetRemoteIdentity().user_id(), std::move(request));
 }
 
 void MandolineUIServicesApp::Create(Connection* connection,
                                     mojom::WindowTreeFactoryRequest request) {
   AddUserIfNecessary(connection);
   if (!window_server_->display_manager()->has_displays()) {
@@ skipping 19 matching lines @@
     mojom::WindowTreeHostFactoryRequest request) {
   UserState* user_state = GetUserState(connection);
   if (!user_state->window_tree_host_factory) {
     user_state->window_tree_host_factory.reset(new ws::WindowTreeHostFactory(
         window_server_.get(), connection->GetRemoteIdentity().user_id(),
         platform_display_init_params_));
   }
   user_state->window_tree_host_factory->AddBinding(std::move(request));
 }
 
-void MandolineUIServicesApp::Create(mojo::Connection* connection,
+void MandolineUIServicesApp::Create(shell::Connection* connection,
                                     mojom::GpuRequest request) {
   DCHECK(platform_display_init_params_.gpu_state);
   new GpuImpl(std::move(request), platform_display_init_params_.gpu_state);
 }
 
 }  // namespace mus