Rename shell namespace to service_manager

mash/quick_launch/quick_launch.cc

 // Copyright 2016 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/quick_launch/quick_launch.h"
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
@@ skipping 17 matching lines @@
 class AuraInit;
 }
 
 namespace mash {
 namespace quick_launch {
 
 class QuickLaunchUI : public views::WidgetDelegateView,
                       public views::TextfieldController {
  public:
   QuickLaunchUI(QuickLaunch* quick_launch,
-                shell::Connector* connector,
+                service_manager::Connector* connector,
                 catalog::mojom::CatalogPtr catalog)
       : quick_launch_(quick_launch),
-    connector_(connector),
+        connector_(connector),
         prompt_(new views::Textfield),
         catalog_(std::move(catalog)) {
     set_background(views::Background::CreateStandardPanelBackground());
     prompt_->set_controller(this);
     AddChildView(prompt_);
 
     UpdateEntries();
   }
   ~QuickLaunchUI() override {
     quick_launch_->RemoveWindow(GetWidget());
@@ skipping 72 matching lines @@
         base::Bind(&QuickLaunchUI::OnGotCatalogEntries,
                    base::Unretained(this)));
   }
 
   void OnGotCatalogEntries(std::vector<catalog::mojom::EntryPtr> entries) {
     for (const auto& entry : entries)
       app_names_.insert(base::UTF8ToUTF16(entry->name));
   }
 
   void Launch(const std::string& name, bool new_window) {
-    std::unique_ptr<shell::Connection> connection = connector_->Connect(name);
+    std::unique_ptr<service_manager::Connection> connection =
+        connector_->Connect(name);
     mojom::LaunchablePtr launchable;
     connection->GetInterface(&launchable);
     connections_.push_back(std::move(connection));
     launchable->Launch(mojom::kWindow,
                        new_window ? mojom::LaunchMode::MAKE_NEW
                                   : mojom::LaunchMode::REUSE);
   }
 
   QuickLaunch* quick_launch_;
-  shell::Connector* connector_;
+  service_manager::Connector* connector_;
   views::Textfield* prompt_;
-  std::vector<std::unique_ptr<shell::Connection>> connections_;
+  std::vector<std::unique_ptr<service_manager::Connection>> connections_;
   catalog::mojom::CatalogPtr catalog_;
   std::set<base::string16> app_names_;
   bool suggestion_rejected_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(QuickLaunchUI);
 };
 
 QuickLaunch::QuickLaunch() {}
 QuickLaunch::~QuickLaunch() {}
 
 void QuickLaunch::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()->is_running())
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
-void QuickLaunch::OnStart(const shell::Identity& identity) {
+void QuickLaunch::OnStart(const service_manager::Identity& identity) {
   tracing_.Initialize(connector(), identity.name());
 
   aura_init_.reset(
       new views::AuraInit(connector(), "views_mus_resources.pak"));
   window_manager_connection_ =
       views::WindowManagerConnection::Create(connector(), identity);
 
   Launch(mojom::kWindow, mojom::LaunchMode::MAKE_NEW);
 }
 
-bool QuickLaunch::OnConnect(const shell::Identity& remote_identity,
-                            shell::InterfaceRegistry* registry) {
+bool QuickLaunch::OnConnect(const service_manager::Identity& remote_identity,
+                            service_manager::InterfaceRegistry* registry) {
   registry->AddInterface<mojom::Launchable>(this);
   return true;
 }
 
 void QuickLaunch::Launch(uint32_t what, mojom::LaunchMode how) {
   bool reuse = how == mojom::LaunchMode::REUSE ||
                how == mojom::LaunchMode::DEFAULT;
   if (reuse && !windows_.empty()) {
     windows_.back()->Activate();
     return;
   }
   catalog::mojom::CatalogPtr catalog;
   connector()->ConnectToInterface("service:catalog", &catalog);
 
   views::Widget* window = views::Widget::CreateWindowWithContextAndBounds(
       new QuickLaunchUI(this, connector(), std::move(catalog)),
       nullptr, gfx::Rect(10, 640, 0, 0));
   window->Show();
   windows_.push_back(window);
 }
 
-void QuickLaunch::Create(const shell::Identity& remote_identity,
+void QuickLaunch::Create(const service_manager::Identity& remote_identity,
                          mojom::LaunchableRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 }  // namespace quick_launch
 }  // namespace mash