Rename shell namespace to service_manager

mash/example/window_type_launcher/window_type_launcher.cc

 // Copyright (c) 2012 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 "mash/example/window_type_launcher/window_type_launcher.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 207 matching lines @@
 }
 
 // The contents view/delegate of a window that shows some buttons that create
 // various window types.
 class WindowTypeLauncherView : public views::WidgetDelegateView,
                                public views::ButtonListener,
                                public views::MenuDelegate,
                                public views::ContextMenuController {
  public:
   explicit WindowTypeLauncherView(WindowTypeLauncher* window_type_launcher,
-                                  shell::Connector* connector)
+                                  service_manager::Connector* connector)
       : window_type_launcher_(window_type_launcher),
         connector_(connector),
         create_button_(
             MdTextButton::Create(this, base::ASCIIToUTF16("Create Window"))),
         always_on_top_button_(MdTextButton::Create(
             this,
             base::ASCIIToUTF16("Create Always On Top Window"))),
         panel_button_(
             MdTextButton::Create(this, base::ASCIIToUTF16("Create Panel"))),
         create_nonresizable_button_(MdTextButton::Create(
@@ skipping 186 matching lines @@
                          MenuItemView::NORMAL);
     // MenuRunner takes ownership of root.
     menu_runner_.reset(new MenuRunner(
         root, MenuRunner::HAS_MNEMONICS | views::MenuRunner::CONTEXT_MENU |
                   views::MenuRunner::ASYNC));
     menu_runner_->RunMenuAt(GetWidget(), NULL, gfx::Rect(point, gfx::Size()),
                             views::MENU_ANCHOR_TOPLEFT, source_type);
   }
 
   WindowTypeLauncher* window_type_launcher_;
-  shell::Connector* connector_;
+  service_manager::Connector* connector_;
   views::Button* create_button_;
   views::Button* always_on_top_button_;
   views::Button* panel_button_;
   views::Button* create_nonresizable_button_;
   views::Button* bubble_button_;
   views::Button* lock_button_;
   views::Button* logout_button_;
   views::Button* switch_user_button_;
   views::Button* widgets_button_;
   views::Button* system_modal_button_;
@@ skipping 16 matching lines @@
 WindowTypeLauncher::~WindowTypeLauncher() {}
 
 void WindowTypeLauncher::RemoveWindow(views::Widget* window) {
   auto it = std::find(windows_.begin(), windows_.end(), window);
   DCHECK(it != windows_.end());
   windows_.erase(it);
   if (windows_.empty())
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
-void WindowTypeLauncher::OnStart(const shell::Identity& identity) {
+void WindowTypeLauncher::OnStart(const service_manager::Identity& identity) {
   aura_init_.reset(
       new views::AuraInit(connector(), "views_mus_resources.pak"));
   window_manager_connection_ =
       views::WindowManagerConnection::Create(connector(), identity);
 }
 
-bool WindowTypeLauncher::OnConnect(const shell::Identity& remote_identity,
-                                   shell::InterfaceRegistry* registry) {
+bool WindowTypeLauncher::OnConnect(
+    const service_manager::Identity& remote_identity,
+    service_manager::InterfaceRegistry* registry) {
   registry->AddInterface<mash::mojom::Launchable>(this);
   return true;
 }
 
 void WindowTypeLauncher::Launch(uint32_t what, mash::mojom::LaunchMode how) {
   bool reuse = how == mash::mojom::LaunchMode::REUSE ||
                how == mash::mojom::LaunchMode::DEFAULT;
   if (reuse && !windows_.empty()) {
     windows_.back()->Activate();
     return;
   }
   views::Widget* window = new views::Widget;
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
   params.delegate = new WindowTypeLauncherView(this, connector());
   window->Init(params);
   window->Show();
   windows_.push_back(window);
 }
 
-void WindowTypeLauncher::Create(const shell::Identity& remote_identity,
-                                mash::mojom::LaunchableRequest request) {
+void WindowTypeLauncher::Create(
+    const service_manager::Identity& remote_identity,
+    mash::mojom::LaunchableRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 MojoResult ServiceMain(MojoHandle service_request_handle) {
-  return shell::ServiceRunner(new WindowTypeLauncher)
+  return service_manager::ServiceRunner(new WindowTypeLauncher)
       .Run(service_request_handle);
 }