Rename shell namespace to service_manager

content/common/service_manager/service_manager_connection_impl.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 "content/common/service_manager/service_manager_connection_impl.h"
 
 #include <queue>
 #include <utility>
 #include <vector>
 
@@ skipping 21 matching lines @@
 
 ServiceManagerConnection::Factory* service_manager_connection_factory = nullptr;
 
 }  // namespace
 
 // A ref-counted object which owns the IO thread state of a
 // ServiceManagerConnectionImpl. This includes Service and ServiceFactory
 // bindings.
 class ServiceManagerConnectionImpl::IOThreadContext
     : public base::RefCountedThreadSafe<IOThreadContext>,
-      public shell::Service,
-      public shell::InterfaceFactory<shell::mojom::ServiceFactory>,
-      public shell::mojom::ServiceFactory {
+      public service_manager::Service,
+      public service_manager::InterfaceFactory<
+          service_manager::mojom::ServiceFactory>,
+      public service_manager::mojom::ServiceFactory {
  public:
-  using InitializeCallback = base::Callback<void(const shell::Identity&)>;
+  using InitializeCallback =
+      base::Callback<void(const service_manager::Identity&)>;
   using ServiceFactoryCallback =
-      base::Callback<void(shell::mojom::ServiceRequest, const std::string&)>;
+      base::Callback<void(service_manager::mojom::ServiceRequest,
+                          const std::string&)>;
 
-  IOThreadContext(shell::mojom::ServiceRequest service_request,
-                  scoped_refptr<base::SequencedTaskRunner> io_task_runner,
-                  std::unique_ptr<shell::Connector> io_thread_connector,
-                  shell::mojom::ConnectorRequest connector_request)
+  IOThreadContext(
+      service_manager::mojom::ServiceRequest service_request,
+      scoped_refptr<base::SequencedTaskRunner> io_task_runner,
+      std::unique_ptr<service_manager::Connector> io_thread_connector,
+      service_manager::mojom::ConnectorRequest connector_request)
       : pending_service_request_(std::move(service_request)),
         io_task_runner_(io_task_runner),
         io_thread_connector_(std::move(io_thread_connector)),
         pending_connector_request_(std::move(connector_request)),
         weak_factory_(this) {
     // This will be reattached by any of the IO thread functions on first call.
     io_thread_checker_.DetachFromThread();
   }
 
   // Safe to call from any thread.
@@ skipping 38 matching lines @@
 
   void RemoveConnectionFilter(int filter_id) {
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&IOThreadContext::RemoveConnectionFilterOnIOThread, this,
                    filter_id));
   }
 
   // Safe to call any time before Start() is called.
   void SetDefaultBinderForBrowserConnection(
-      const shell::InterfaceRegistry::Binder& binder) {
+      const service_manager::InterfaceRegistry::Binder& binder) {
     DCHECK(!started_);
     default_browser_binder_ = base::Bind(
         &IOThreadContext::CallBinderOnTaskRunner,
         base::ThreadTaskRunnerHandle::Get(), binder);
   }
 
  private:
   friend class base::RefCountedThreadSafe<IOThreadContext>;
 
   class MessageLoopObserver : public base::MessageLoop::DestructionObserver {
@@ skipping 30 matching lines @@
     base::WeakPtr<IOThreadContext> context_;
 
     DISALLOW_COPY_AND_ASSIGN(MessageLoopObserver);
   };
 
   ~IOThreadContext() override {}
 
   void StartOnIOThread() {
     // Should bind |io_thread_checker_| to the context's thread.
     DCHECK(io_thread_checker_.CalledOnValidThread());
-    service_context_.reset(new shell::ServiceContext(
+    service_context_.reset(new service_manager::ServiceContext(
         this, std::move(pending_service_request_),
         std::move(io_thread_connector_),
         std::move(pending_connector_request_)));
 
     // MessageLoopObserver owns itself.
     message_loop_observer_ =
         new MessageLoopObserver(weak_factory_.GetWeakPtr());
   }
 
   void ShutDownOnIOThread() {
@@ skipping 31 matching lines @@
     DCHECK(it != connection_filters_.end());
     connection_filters_.erase(it);
   }
 
   void OnBrowserConnectionLost() {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     has_browser_connection_ = false;
   }
 
   /////////////////////////////////////////////////////////////////////////////
-  // shell::Service implementation
+  // service_manager::Service implementation
 
-  void OnStart(const shell::Identity& identity) override {
+  void OnStart(const service_manager::Identity& identity) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     DCHECK(!initialize_handler_.is_null());
     id_ = identity;
 
     InitializeCallback handler = base::ResetAndReturn(&initialize_handler_);
     callback_task_runner_->PostTask(FROM_HERE, base::Bind(handler, identity));
   }
 
-  bool OnConnect(const shell::Identity& remote_identity,
-                 shell::InterfaceRegistry* registry) override {
+  bool OnConnect(const service_manager::Identity& remote_identity,
+                 service_manager::InterfaceRegistry* registry) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     std::string remote_service = remote_identity.name();
     if (remote_service == "service:shell") {
       // Only expose the SCF interface to the shell.
-      registry->AddInterface<shell::mojom::ServiceFactory>(this);
+      registry->AddInterface<service_manager::mojom::ServiceFactory>(this);
       return true;
     }
 
     bool accept = false;
     {
       base::AutoLock lock(lock_);
       for (auto& entry : connection_filters_) {
         accept |= entry.second->OnConnect(remote_identity, registry,
                                           service_context_->connector());
       }
@@ skipping 12 matching lines @@
     return accept;
   }
 
   bool OnStop() override {
     ClearConnectionFiltersOnIOThread();
     callback_task_runner_->PostTask(FROM_HERE, stop_callback_);
     return true;
   }
 
   /////////////////////////////////////////////////////////////////////////////
-  // shell::InterfaceFactory<shell::mojom::ServiceFactory> implementation
+  // service_manager::InterfaceFactory<service_manager::mojom::ServiceFactory>
+  // implementation
 
-  void Create(const shell::Identity& remote_identity,
-              shell::mojom::ServiceFactoryRequest request) override {
+  void Create(const service_manager::Identity& remote_identity,
+              service_manager::mojom::ServiceFactoryRequest request) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     factory_bindings_.AddBinding(this, std::move(request));
   }
 
   /////////////////////////////////////////////////////////////////////////////
-  // shell::mojom::ServiceFactory implementation
+  // service_manager::mojom::ServiceFactory implementation
 
-  void CreateService(shell::mojom::ServiceRequest request,
+  void CreateService(service_manager::mojom::ServiceRequest request,
                      const std::string& name) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     callback_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(create_service_callback_, base::Passed(&request), name));
   }
 
   static void CallBinderOnTaskRunner(
       scoped_refptr<base::SequencedTaskRunner> task_runner,
-      const shell::InterfaceRegistry::Binder& binder,
+      const service_manager::InterfaceRegistry::Binder& binder,
       const std::string& interface_name,
       mojo::ScopedMessagePipeHandle request_handle) {
     task_runner->PostTask(FROM_HERE, base::Bind(binder, interface_name,
                                                 base::Passed(&request_handle)));
   }
 
   base::ThreadChecker io_thread_checker_;
   bool started_ = false;
 
   // Temporary state established on construction and consumed on the IO thread
   // once the connection is started.
-  shell::mojom::ServiceRequest pending_service_request_;
+  service_manager::mojom::ServiceRequest pending_service_request_;
   scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
-  std::unique_ptr<shell::Connector> io_thread_connector_;
-  shell::mojom::ConnectorRequest pending_connector_request_;
+  std::unique_ptr<service_manager::Connector> io_thread_connector_;
+  service_manager::mojom::ConnectorRequest pending_connector_request_;
 
   // TaskRunner on which to run our owner's callbacks, i.e. the ones passed to
   // Start().
   scoped_refptr<base::SequencedTaskRunner> callback_task_runner_;
 
   // Callback to run once Service::OnStart is invoked.
   InitializeCallback initialize_handler_;
 
   // Callback to run when a new Service request is received.
   ServiceFactoryCallback create_service_callback_;
 
   // Callback to run if the service is stopped by the service manager.
   base::Closure stop_callback_;
 
   // Called once a connection has been received from the browser process & the
   // default binder (below) has been set up.
   bool has_browser_connection_ = false;
 
-  shell::Identity id_;
+  service_manager::Identity id_;
 
   // Default binder callback used for the browser connection's
   // InterfaceRegistry.
   //
   // TODO(rockot): Remove this once all interfaces exposed to the browser are
   // exposed via a ConnectionFilter.
-  shell::InterfaceRegistry::Binder default_browser_binder_;
+  service_manager::InterfaceRegistry::Binder default_browser_binder_;
 
-  std::unique_ptr<shell::ServiceContext> service_context_;
-  mojo::BindingSet<shell::mojom::ServiceFactory> factory_bindings_;
+  std::unique_ptr<service_manager::ServiceContext> service_context_;
+  mojo::BindingSet<service_manager::mojom::ServiceFactory> factory_bindings_;
   int next_filter_id_ = kInvalidConnectionFilterId;
 
   // Not owned.
   MessageLoopObserver* message_loop_observer_ = nullptr;
 
   // Guards |connection_filters_|.
   base::Lock lock_;
   std::map<int, std::unique_ptr<ConnectionFilter>> connection_filters_;
 
   base::WeakPtrFactory<IOThreadContext> weak_factory_;
@@ skipping 23 matching lines @@
 }
 
 // static
 void ServiceManagerConnection::SetFactoryForTest(Factory* factory) {
   DCHECK(!g_connection_for_process.Get());
   service_manager_connection_factory = factory;
 }
 
 // static
 std::unique_ptr<ServiceManagerConnection> ServiceManagerConnection::Create(
-    shell::mojom::ServiceRequest request,
+    service_manager::mojom::ServiceRequest request,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner) {
   if (service_manager_connection_factory)
     return service_manager_connection_factory->Run();
   return base::MakeUnique<ServiceManagerConnectionImpl>(
       std::move(request), io_task_runner);
 }
 
 ServiceManagerConnection::~ServiceManagerConnection() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManagerConnectionImpl, public:
 
 ServiceManagerConnectionImpl::ServiceManagerConnectionImpl(
-    shell::mojom::ServiceRequest request,
+    service_manager::mojom::ServiceRequest request,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner)
     : weak_factory_(this) {
-  shell::mojom::ConnectorRequest connector_request;
-  connector_ = shell::Connector::Create(&connector_request);
+  service_manager::mojom::ConnectorRequest connector_request;
+  connector_ = service_manager::Connector::Create(&connector_request);
 
-  std::unique_ptr<shell::Connector> io_thread_connector = connector_->Clone();
+  std::unique_ptr<service_manager::Connector> io_thread_connector =
+      connector_->Clone();
   context_ = new IOThreadContext(
       std::move(request), io_task_runner, std::move(io_thread_connector),
       std::move(connector_request));
 }
 
 ServiceManagerConnectionImpl::~ServiceManagerConnectionImpl() {
   context_->ShutDown();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManagerConnectionImpl, ServiceManagerConnection implementation:
 
 void ServiceManagerConnectionImpl::Start() {
   context_->Start(
       base::Bind(&ServiceManagerConnectionImpl::OnContextInitialized,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceManagerConnectionImpl::CreateService,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceManagerConnectionImpl::OnConnectionLost,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ServiceManagerConnectionImpl::SetInitializeHandler(
     const base::Closure& handler) {
   DCHECK(initialize_handler_.is_null());
   initialize_handler_ = handler;
 }
 
-shell::Connector* ServiceManagerConnectionImpl::GetConnector() {
+service_manager::Connector* ServiceManagerConnectionImpl::GetConnector() {
   return connector_.get();
 }
 
-const shell::Identity& ServiceManagerConnectionImpl::GetIdentity() const {
+const service_manager::Identity& ServiceManagerConnectionImpl::GetIdentity()
+    const {
   return identity_;
 }
 
 void ServiceManagerConnectionImpl::SetConnectionLostClosure(
     const base::Closure& closure) {
   connection_lost_handler_ = closure;
 }
 
 void ServiceManagerConnectionImpl::SetupInterfaceRequestProxies(
-    shell::InterfaceRegistry* registry,
-    shell::InterfaceProvider* provider) {
+    service_manager::InterfaceRegistry* registry,
+    service_manager::InterfaceProvider* provider) {
   // It's safe to bind |registry| as a raw pointer because the caller must
   // guarantee that it outlives |this|, and |this| is bound as a weak ptr here.
   context_->SetDefaultBinderForBrowserConnection(
       base::Bind(&ServiceManagerConnectionImpl::GetInterface,
                  weak_factory_.GetWeakPtr(), registry));
 
   // TODO(beng): remove provider parameter.
 }
 
 int ServiceManagerConnectionImpl::AddConnectionFilter(
@@ skipping 18 matching lines @@
 }
 
 void ServiceManagerConnectionImpl::AddServiceRequestHandler(
     const std::string& name,
     const ServiceRequestHandler& handler) {
   auto result = request_handlers_.insert(std::make_pair(name, handler));
   DCHECK(result.second);
 }
 
 void ServiceManagerConnectionImpl::CreateService(
-    shell::mojom::ServiceRequest request,
+    service_manager::mojom::ServiceRequest request,
     const std::string& name) {
   auto it = request_handlers_.find(name);
   if (it != request_handlers_.end())
     it->second.Run(std::move(request));
 }
 
 void ServiceManagerConnectionImpl::OnContextInitialized(
-    const shell::Identity& identity) {
+    const service_manager::Identity& identity) {
   identity_ = identity;
   if (!initialize_handler_.is_null())
     base::ResetAndReturn(&initialize_handler_).Run();
 }
 
 void ServiceManagerConnectionImpl::OnConnectionLost() {
   if (!connection_lost_handler_.is_null())
     connection_lost_handler_.Run();
 }
 
 void ServiceManagerConnectionImpl::GetInterface(
-    shell::mojom::InterfaceProvider* provider,
+    service_manager::mojom::InterfaceProvider* provider,
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle request_handle) {
   provider->GetInterface(interface_name, std::move(request_handle));
 }
 
 }  // namespace content