Move shell service to toplevel shell namespace

services/shell/shell.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 "services/shell/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 13 matching lines @@
 #include "mojo/util/filename_util.h"
 #include "services/shell/connect_util.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/shell/public/cpp/names.h"
 #include "services/shell/public/cpp/shell_connection.h"
 #include "services/shell/public/interfaces/connector.mojom.h"
 #include "services/shell/public/interfaces/shell.mojom.h"
 #include "services/shell/public/interfaces/shell_client.mojom.h"
 #include "url/gurl.h"
 
-namespace mojo {
 namespace shell {
+
 namespace {
+
 const char kCatalogName[] = "mojo:catalog";
 const char kShellName[] = "mojo:shell";
 const char kCapabilityClass_UserID[] = "user_id";
 const char kCapabilityClass_ClientProcess[] = "client_process";
 const char kCapabilityClass_InstanceName[] = "instance_name";
 const char kCapabilityClass_AllUsers[] = "all_users";
 
 void EmptyResolverCallback(mojom::ResolveResultPtr result) {}
 
-}
+}  // namespace
 
 Identity CreateShellIdentity() {
   return Identity(kShellName, mojom::kRootUserID);
 }
 
 Identity CreateCatalogIdentity() {
   return Identity(kCatalogName, mojom::kRootUserID);
 }
 
 CapabilitySpec GetPermissiveCapabilities() {
@@ skipping 72 matching lines @@
   ~Instance() override {
     if (parent_)
       parent_->RemoveChild(this);
     // |children_| will be modified during destruction.
     std::set<Instance*> children = children_;
     for (auto child : children)
       shell_->OnInstanceError(child);
   }
 
   Instance* parent() { return parent_; }
+
   void AddChild(Instance* child) {
     children_.insert(child);
     child->parent_ = this;
   }
+
   void RemoveChild(Instance* child) {
     auto it = children_.find(child);
     DCHECK(it != children_.end());
     children_.erase(it);
     child->parent_ = nullptr;
   }
 
-  void ConnectToClient(scoped_ptr<ConnectParams> params) {
+  void ConnectToClient(std::unique_ptr<ConnectParams> params) {
     CHECK(shell_client_.is_bound());
     params->connect_callback().Run(mojom::ConnectResult::SUCCEEDED,
                                    identity_.user_id(), id_);
     uint32_t source_id = mojom::kInvalidInstanceID;
     CapabilityRequest spec;
     spec.interfaces.insert("*");
     Instance* source = shell_->GetExistingInstance(params->source());
     if (source) {
       spec = GenerateCapabilityRequestForConnection(
           source->capability_spec_, identity_, capability_spec_);
@@ skipping 21 matching lines @@
     mojom::ShellClientPtr client;
     client.Bind(mojom::ShellClientPtrInfo(
         std::move(client_process_connection->shell_client), 0));
     pid_receiver_binding_.Bind(
         std::move(client_process_connection->pid_receiver_request));
     StartWithClient(std::move(client));
   }
 
   void StartWithFilePath(const base::FilePath& path) {
     CHECK(!shell_client_);
-    scoped_ptr<NativeRunner> runner =
+    std::unique_ptr<NativeRunner> runner =
         shell_->native_runner_factory_->Create(path);
     bool start_sandboxed = false;
     mojom::ShellClientPtr client = runner->Start(
         path, identity_, start_sandboxed,
         base::Bind(&Instance::PIDAvailable, weak_factory_.GetWeakPtr()),
         base::Bind(&shell::Shell::CleanupRunner,
                    shell_->weak_ptr_factory_.GetWeakPtr(), runner.get()));
     shell_->native_runners_.push_back(std::move(runner));
     StartWithClient(std::move(client));
   }
@@ skipping 31 matching lines @@
 
     if (!ValidateIdentity(target, callback))
       return;
     if (!ValidateClientProcessConnection(&client_process_connection, target,
                                          callback)) {
       return;
     }
     if (!ValidateCapabilities(target, callback))
       return;
 
-    scoped_ptr<ConnectParams> params(new ConnectParams);
+    std::unique_ptr<ConnectParams> params(new ConnectParams);
     params->set_source(identity_);
     params->set_target(target);
     params->set_remote_interfaces(std::move(remote_interfaces));
     params->set_local_interfaces(std::move(local_interfaces));
     params->set_client_process_connection(std::move(client_process_connection));
     params->set_connect_callback(callback);
     shell_->Connect(std::move(params));
   }
 
   void Clone(mojom::ConnectorRequest request) override {
@@ skipping 150 matching lines @@
   shell::Shell* const shell_;
 
   // An id that identifies this instance. Distinct from pid, as a single process
   // may vend multiple application instances, and this object may exist before a
   // process is launched.
   const uint32_t id_;
   const Identity identity_;
   const CapabilitySpec capability_spec_;
   const bool allow_any_application_;
   mojom::ShellClientPtr shell_client_;
-  Binding<mojom::PIDReceiver> pid_receiver_binding_;
-  BindingSet<mojom::Connector> connectors_;
-  BindingSet<mojom::Shell> shell_bindings_;
+  mojo::Binding<mojom::PIDReceiver> pid_receiver_binding_;
+  mojo::BindingSet<mojom::Connector> connectors_;
+  mojo::BindingSet<mojom::Shell> shell_bindings_;
   NativeRunner* runner_ = nullptr;
   base::ProcessId pid_ = base::kNullProcessId;
   Instance* parent_ = nullptr;
   std::set<Instance*> children_;
   base::WeakPtrFactory<Instance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
 // static
 Shell::TestAPI::TestAPI(Shell* shell) : shell_(shell) {}
 Shell::TestAPI::~TestAPI() {}
 
 bool Shell::TestAPI::HasRunningInstanceForName(const std::string& name) const {
   for (const auto& entry : shell_->identity_to_instance_) {
     if (entry.first.name() == name)
       return true;
   }
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
-Shell::Shell(scoped_ptr<NativeRunnerFactory> native_runner_factory,
+Shell::Shell(std::unique_ptr<NativeRunnerFactory> native_runner_factory,
              mojom::ShellClientPtr catalog)
     : native_runner_factory_(std::move(native_runner_factory)),
       weak_ptr_factory_(this) {
   mojom::ShellClientPtr client;
-  mojom::ShellClientRequest request = GetProxy(&client);
+  mojom::ShellClientRequest request = mojo::GetProxy(&client);
   Instance* instance = CreateInstance(Identity(), CreateShellIdentity(),
                                       GetPermissiveCapabilities());
   instance->StartWithClient(std::move(client));
   singletons_.insert(kShellName);
   shell_connection_.reset(new ShellConnection(this, std::move(request)));
 
   if (catalog)
     InitCatalog(std::move(catalog));
 }
 
 Shell::~Shell() {
   TerminateShellConnections();
   STLDeleteValues(&name_to_loader_);
   for (auto& runner : native_runners_)
     runner.reset();
 }
 
 void Shell::SetInstanceQuitCallback(
     base::Callback<void(const Identity&)> callback) {
   instance_quit_callback_ = callback;
 }
 
-void Shell::Connect(scoped_ptr<ConnectParams> params) {
+void Shell::Connect(std::unique_ptr<ConnectParams> params) {
   Connect(std::move(params), nullptr);
 }
 
 mojom::ShellClientRequest Shell::InitInstanceForEmbedder(
     const std::string& name) {
-  scoped_ptr<ConnectParams> params(new ConnectParams);
+  std::unique_ptr<ConnectParams> params(new ConnectParams);
 
   Identity embedder_identity(name, mojom::kRootUserID);
   params->set_source(embedder_identity);
   params->set_target(embedder_identity);
 
   mojom::ShellClientPtr client;
-  mojom::ShellClientRequest request = GetProxy(&client);
+  mojom::ShellClientRequest request = mojo::GetProxy(&client);
   Connect(std::move(params), std::move(client));
 
   return request;
 }
 
-void Shell::SetLoaderForName(scoped_ptr<Loader> loader,
+void Shell::SetLoaderForName(std::unique_ptr<Loader> loader,
                              const std::string& name) {
   auto it = name_to_loader_.find(name);
   if (it != name_to_loader_.end())
     delete it->second;
   name_to_loader_[name] = loader.release();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, ShellClient implementation:
 
@@ skipping 18 matching lines @@
 
 void Shell::InitCatalog(mojom::ShellClientPtr catalog) {
   Instance* instance = CreateInstance(CreateShellIdentity(),
                                       CreateCatalogIdentity(),
                                       CapabilitySpec());
   singletons_.insert(kCatalogName);
   instance->StartWithClient(std::move(catalog));
 
   // TODO(beng): this doesn't work anymore.
   // Seed the catalog with manifest info for the shell & catalog.
-  shell::mojom::ShellResolverPtr resolver;
+  mojom::ShellResolverPtr resolver;
   shell_connection_->connector()->ConnectToInterface(kCatalogName, &resolver);
   resolver->ResolveMojoName(kCatalogName, base::Bind(&EmptyResolverCallback));
   resolver->ResolveMojoName(kShellName, base::Bind(&EmptyResolverCallback));
 }
 
 void Shell::TerminateShellConnections() {
   Instance* instance = GetExistingInstance(CreateShellIdentity());
   DCHECK(instance);
   OnInstanceError(instance);
 }
 
 void Shell::OnInstanceError(Instance* instance) {
   const Identity identity = instance->identity();
   // Remove the shell.
   auto it = identity_to_instance_.find(identity);
   DCHECK(it != identity_to_instance_.end());
   int id = instance->id();
   delete it->second;
   identity_to_instance_.erase(it);
   instance_listeners_.ForAllPtrs([this, id](mojom::InstanceListener* listener) {
                                    listener->InstanceDestroyed(id);
                                  });
   if (!instance_quit_callback_.is_null())
     instance_quit_callback_.Run(identity);
 }
 
-void Shell::Connect(scoped_ptr<ConnectParams> params,
+void Shell::Connect(std::unique_ptr<ConnectParams> params,
                     mojom::ShellClientPtr client) {
   TRACE_EVENT_INSTANT1("mojo_shell", "Shell::Connect",
                        TRACE_EVENT_SCOPE_THREAD, "original_name",
                        params->target().name());
   DCHECK(IsValidName(params->target().name()));
   DCHECK(base::IsValidGUID(params->target().user_id()));
   DCHECK_NE(mojom::kInheritUserID, params->target().user_id());
   DCHECK(!client.is_bound() || !identity_to_instance_.count(params->target()));
 
   // Connect to an existing matching instance, if possible.
   if (!client.is_bound() && ConnectToExistingInstance(&params))
     return;
 
   // The catalog needs to see the source identity as that of the originating
   // app so it loads the correct store. Since the catalog is itself run as root
   // when this re-enters Connect() it'll be handled by
   // ConnectToExistingInstance().
   mojom::ShellResolverPtr resolver;
   ConnectToInterface(this, Identity(kShellName, params->target().user_id()),
                      CreateCatalogIdentity(), &resolver);
 
   std::string name = params->target().name();
   mojom::ShellResolver* resolver_raw = resolver.get();
   resolver_raw->ResolveMojoName(
-      name,
-      base::Bind(&Shell::OnGotResolvedName, weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(std::move(resolver)), base::Passed(&params),
-                 base::Passed(&client)));
+      name, base::Bind(&shell::Shell::OnGotResolvedName,
+                       weak_ptr_factory_.GetWeakPtr(),
+                       base::Passed(std::move(resolver)), base::Passed(&params),
+                       base::Passed(&client)));
 }
 
 Shell::Instance* Shell::GetExistingInstance(const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
   Instance* instance = it != identity_to_instance_.end() ? it->second : nullptr;
   if (instance)
     return instance;
 
   if (singletons_.find(identity.name()) != singletons_.end()) {
     for (auto entry : identity_to_instance_) {
       if (entry.first.name() == identity.name() &&
           entry.first.instance() == identity.instance()) {
         return entry.second;
       }
     }
   }
   return nullptr;
 }
 
 void Shell::NotifyPIDAvailable(uint32_t id, base::ProcessId pid) {
   instance_listeners_.ForAllPtrs([id, pid](mojom::InstanceListener* listener) {
                                    listener->InstancePIDAvailable(id, pid);
                                  });
 }
 
-bool Shell::ConnectToExistingInstance(scoped_ptr<ConnectParams>* params) {
+bool Shell::ConnectToExistingInstance(std::unique_ptr<ConnectParams>* params) {
   Instance* instance = GetExistingInstance((*params)->target());
   if (instance)
     instance->ConnectToClient(std::move(*params));
   return !!instance;
 }
 
 Shell::Instance* Shell::CreateInstance(const Identity& source,
                                        const Identity& target,
                                        const CapabilitySpec& spec) {
   CHECK(target.user_id() != mojom::kInheritUserID);
   Instance* instance = new Instance(this, target, spec);
   DCHECK(identity_to_instance_.find(target) ==
          identity_to_instance_.end());
   Instance* source_instance = GetExistingInstance(source);
   if (source_instance)
     source_instance->AddChild(instance);
   identity_to_instance_[target] = instance;
   mojom::InstanceInfoPtr info = instance->CreateInstanceInfo();
   instance_listeners_.ForAllPtrs(
       [this, &info](mojom::InstanceListener* listener) {
         listener->InstanceCreated(info.Clone());
       });
   return instance;
 }
 
 void Shell::AddInstanceListener(mojom::InstanceListenerPtr listener) {
   // TODO(beng): filter instances provided by those visible to this client.
-  Array<mojom::InstanceInfoPtr> instances;
+  mojo::Array<mojom::InstanceInfoPtr> instances;
   for (auto& instance : identity_to_instance_)
     instances.push_back(instance.second->CreateInstanceInfo());
   listener->SetExistingInstances(std::move(instances));
 
   instance_listeners_.AddPtr(std::move(listener));
 }
 
 void Shell::CreateShellClientWithFactory(const Identity& shell_client_factory,
                                          const std::string& name,
                                          mojom::ShellClientRequest request) {
   mojom::ShellClientFactory* factory =
       GetShellClientFactory(shell_client_factory);
   factory->CreateShellClient(std::move(request), name);
 }
 
 mojom::ShellClientFactory* Shell::GetShellClientFactory(
     const Identity& shell_client_factory_identity) {
   auto it = shell_client_factories_.find(shell_client_factory_identity);
   if (it != shell_client_factories_.end())
     return it->second.get();
 
   Identity source_identity(kShellName, mojom::kInheritUserID);
   mojom::ShellClientFactoryPtr factory;
   ConnectToInterface(this, source_identity, shell_client_factory_identity,
                      &factory);
   mojom::ShellClientFactory* factory_interface = factory.get();
-  factory.set_connection_error_handler(
-      base::Bind(&Shell::OnShellClientFactoryLost,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 shell_client_factory_identity));
+  factory.set_connection_error_handler(base::Bind(
+      &shell::Shell::OnShellClientFactoryLost, weak_ptr_factory_.GetWeakPtr(),
+      shell_client_factory_identity));
   shell_client_factories_[shell_client_factory_identity] = std::move(factory);
   return factory_interface;
 }
 
 void Shell::OnShellClientFactoryLost(const Identity& which) {
   // Remove the mapping.
   auto it = shell_client_factories_.find(which);
   DCHECK(it != shell_client_factories_.end());
   shell_client_factories_.erase(it);
 }
 
 void Shell::OnGotResolvedName(mojom::ShellResolverPtr resolver,
-                              scoped_ptr<ConnectParams> params,
+                              std::unique_ptr<ConnectParams> params,
                               mojom::ShellClientPtr client,
                               mojom::ResolveResultPtr result) {
   std::string instance_name = params->target().instance();
   if (instance_name == GetNamePath(params->target().name()) &&
       result->qualifier != GetNamePath(result->resolved_name)) {
     instance_name = result->qualifier;
   }
   Identity target(params->target().name(), params->target().user_id(),
                   instance_name);
   params->set_target(target);
@@ skipping 50 matching lines @@
       CHECK(!result->package_url.is_null() && !result->capabilities.is_null());
 
       if (target.name() != result->resolved_name) {
         instance->StartWithClient(std::move(client));
         Identity factory(result->resolved_name, target.user_id(),
                          instance_name);
         CreateShellClientWithFactory(factory, target.name(),
                                      std::move(request));
       } else {
         instance->StartWithFilePath(
-            util::UrlToFilePath(result->package_url.To<GURL>()));
+            mojo::util::UrlToFilePath(result->package_url.To<GURL>()));
       }
     }
   }
 
   // Now that the instance has a ShellClient, we can connect to it.
   instance->ConnectToClient(std::move(params));
 }
 
 bool Shell::LoadWithLoader(const Identity& target,
                            mojom::ShellClientRequest* request) {
@@ skipping 18 matching lines @@
 void Shell::CleanupRunner(NativeRunner* runner) {
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace shell
-}  // namespace mojo