Rename shell namespace to service_manager

content/child/child_thread_impl.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 "content/child/child_thread_impl.h"
 
 #include <signal.h>
 #include <string>
 #include <utility>
 
@@ skipping 245 matching lines @@
   mojo::edk::SetParentPipeHandle(std::move(platform_channel));
 }
 
 class ChannelBootstrapFilter : public ConnectionFilter {
  public:
   explicit ChannelBootstrapFilter(IPC::mojom::ChannelBootstrapPtrInfo bootstrap)
       : bootstrap_(std::move(bootstrap)), weak_factory_(this) {}
 
  private:
   // ConnectionFilter:
-  bool OnConnect(const shell::Identity& remote_identity,
-                 shell::InterfaceRegistry* registry,
-                 shell::Connector* connector) override {
+  bool OnConnect(const service_manager::Identity& remote_identity,
+                 service_manager::InterfaceRegistry* registry,
+                 service_manager::Connector* connector) override {
     if (remote_identity.name() != kBrowserServiceName)
       return false;
 
     registry->AddInterface(base::Bind(&ChannelBootstrapFilter::CreateBootstrap,
                                       weak_factory_.GetWeakPtr()));
     return true;
   }
 
   void CreateBootstrap(IPC::mojom::ChannelBootstrapRequest request) {
     DCHECK(bootstrap_.is_valid());
@@ skipping 166 matching lines @@
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         switches::kServiceRequestChannelToken);
   } else {
     service_request_token = options.in_process_service_request_token;
   }
   if (!service_request_token.empty()) {
     mojo::ScopedMessagePipeHandle handle =
         mojo::edk::CreateChildMessagePipe(service_request_token);
     DCHECK(handle.is_valid());
     service_manager_connection_ = ServiceManagerConnection::Create(
-        mojo::MakeRequest<shell::mojom::Service>(std::move(handle)),
+        mojo::MakeRequest<service_manager::mojom::Service>(std::move(handle)),
         GetIOTaskRunner());
 
     // When connect_to_browser is true, we obtain interfaces from the browser
     // process by connecting to it, rather than from the incoming interface
     // provider. Exposed interfaces are subject to manifest capability spec.
-    shell::InterfaceProvider* remote_interfaces = nullptr;
+    service_manager::InterfaceProvider* remote_interfaces = nullptr;
     if (options.connect_to_browser) {
       browser_connection_ =
           service_manager_connection_->GetConnector()->Connect(
               kBrowserServiceName);
     } else {
       remote_interfaces = GetRemoteInterfaces();
     }
 
     // TODO(rockot): Remove this once all child-to-browser interface connections
     // are made via a Connector rather than directly through an
@@ skipping 176 matching lines @@
 }
 
 void ChildThreadImpl::RecordComputedAction(const std::string& action) {
     NOTREACHED();
 }
 
 ServiceManagerConnection* ChildThreadImpl::GetServiceManagerConnection() {
   return service_manager_connection_.get();
 }
 
-shell::InterfaceRegistry* ChildThreadImpl::GetInterfaceRegistry() {
+service_manager::InterfaceRegistry* ChildThreadImpl::GetInterfaceRegistry() {
   if (!interface_registry_.get())
-    interface_registry_.reset(new shell::InterfaceRegistry);
+    interface_registry_.reset(new service_manager::InterfaceRegistry);
   return interface_registry_.get();
 }
 
-shell::InterfaceProvider* ChildThreadImpl::GetRemoteInterfaces() {
+service_manager::InterfaceProvider* ChildThreadImpl::GetRemoteInterfaces() {
   if (browser_connection_)
     return browser_connection_->GetRemoteInterfaces();
 
   if (!remote_interfaces_.get())
-    remote_interfaces_.reset(new shell::InterfaceProvider);
+    remote_interfaces_.reset(new service_manager::InterfaceProvider);
   return remote_interfaces_.get();
 }
 
 IPC::MessageRouter* ChildThreadImpl::GetRouter() {
   DCHECK(message_loop_->task_runner()->BelongsToCurrentThread());
   return &router_;
 }
 
 mojom::RouteProvider* ChildThreadImpl::GetRemoteRouteProvider() {
   if (!remote_route_provider_) {
@@ skipping 184 matching lines @@
   Listener* route = router_.GetRoute(routing_id);
   if (route)
     route->OnAssociatedInterfaceRequest(name, request.PassHandle());
 }
 
 bool ChildThreadImpl::IsInBrowserProcess() const {
   return static_cast<bool>(browser_process_io_runner_);
 }
 
 }  // namespace content