Move shell service to toplevel shell namespace

services/shell/tests/connect/connect_test_app.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 <memory>
+
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/shell/public/cpp/application_runner.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/shell/public/cpp/interface_factory.h"
 #include "services/shell/public/cpp/shell_client.h"
 #include "services/shell/public/interfaces/connector.mojom.h"
 #include "services/shell/tests/connect/connect_test.mojom.h"
 
-namespace mojo {
 namespace shell {
+
 namespace {
+
 void QuitLoop(base::RunLoop* loop) {
   loop->Quit();
 }
 
 void ReceiveString(std::string* string, base::RunLoop* loop,
                    const std::string& response) {
   *string = response;
   loop->Quit();
 }
-}
+
+}  // namespace
 
 using GetTitleCallback = test::mojom::ConnectTestService::GetTitleCallback;
 
 class ConnectTestApp : public ShellClient,
                        public InterfaceFactory<test::mojom::ConnectTestService>,
                        public InterfaceFactory<test::mojom::StandaloneApp>,
                        public InterfaceFactory<test::mojom::BlockedInterface>,
                        public InterfaceFactory<test::mojom::UserIdTest>,
                        public test::mojom::ConnectTestService,
                        public test::mojom::StandaloneApp,
                        public test::mojom::BlockedInterface,
                        public test::mojom::UserIdTest {
  public:
   ConnectTestApp() {}
   ~ConnectTestApp() override {}
 
  private:
-  // mojo::ShellClient:
+  // shell::ShellClient:
   void Initialize(Connector* connector, const Identity& identity,
                   uint32_t id) override {
     connector_ = connector;
     identity_ = identity;
     id_ = id;
     bindings_.set_connection_error_handler(
         base::Bind(&ConnectTestApp::OnConnectionError,
                    base::Unretained(this)));
     standalone_bindings_.set_connection_error_handler(
         base::Bind(&ConnectTestApp::OnConnectionError,
@@ skipping 49 matching lines @@
     callback.Run("APP");
   }
   void GetInstance(const GetInstanceCallback& callback) override {
     callback.Run(identity_.instance());
   }
 
   // test::mojom::StandaloneApp:
   void ConnectToAllowedAppInBlockedPackage(
       const ConnectToAllowedAppInBlockedPackageCallback& callback) override {
     base::RunLoop run_loop;
-    scoped_ptr<Connection> connection =
+    std::unique_ptr<Connection> connection =
         connector_->Connect("mojo:connect_test_a");
     connection->SetConnectionLostClosure(
         base::Bind(&ConnectTestApp::OnConnectionBlocked,
                    base::Unretained(this), callback, &run_loop));
     test::mojom::ConnectTestServicePtr test_service;
     connection->GetInterface(&test_service);
     test_service->GetTitle(
         base::Bind(&ConnectTestApp::OnGotTitle, base::Unretained(this),
                    callback, &run_loop));
     {
       // This message is dispatched as a task on the same run loop, so we need
       // to allow nesting in order to pump additional signals.
       base::MessageLoop::ScopedNestableTaskAllower allow(
           base::MessageLoop::current());
       run_loop.Run();
     }
   }
   void ConnectToClassInterface(
       const ConnectToClassInterfaceCallback& callback) override {
-    scoped_ptr<Connection> connection =
+    std::unique_ptr<Connection> connection =
         connector_->Connect("mojo:connect_test_class_app");
     test::mojom::ClassInterfacePtr class_interface;
     connection->GetInterface(&class_interface);
     std::string ping_response;
     {
       base::RunLoop loop;
       class_interface->Ping(base::Bind(&ReceiveString, &ping_response, &loop));
       base::MessageLoop::ScopedNestableTaskAllower allow(
           base::MessageLoop::current());
       loop.Run();
@@ skipping 14 matching lines @@
   // test::mojom::BlockedInterface:
   void GetTitleBlocked(const GetTitleBlockedCallback& callback) override {
     callback.Run("Called Blocked Interface!");
   }
 
   // test::mojom::UserIdTest:
   void ConnectToClassAppAsDifferentUser(
       mojom::IdentityPtr target,
       const ConnectToClassAppAsDifferentUserCallback& callback) override {
     Connector::ConnectParams params(target.To<Identity>());
-    scoped_ptr<Connection> connection = connector_->Connect(&params);
+    std::unique_ptr<Connection> connection = connector_->Connect(&params);
     {
       base::RunLoop loop;
       connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
       base::MessageLoop::ScopedNestableTaskAllower allow(
           base::MessageLoop::current());
       loop.Run();
     }
     callback.Run(static_cast<int32_t>(connection->GetResult()),
                  mojom::Identity::From(connection->GetRemoteIdentity()));
   }
@@ skipping 13 matching lines @@
     run_loop->Quit();
   }
 
   void OnConnectionError() {
     if (bindings_.empty() && standalone_bindings_.empty())
       base::MessageLoop::current()->QuitWhenIdle();
   }
 
   Connector* connector_ = nullptr;
   Identity identity_;
-  uint32_t id_ = shell::mojom::kInvalidInstanceID;
-  BindingSet<test::mojom::ConnectTestService> bindings_;
-  BindingSet<test::mojom::StandaloneApp> standalone_bindings_;
-  BindingSet<test::mojom::BlockedInterface> blocked_bindings_;
-  BindingSet<test::mojom::UserIdTest> user_id_test_bindings_;
+  uint32_t id_ = mojom::kInvalidInstanceID;
+  mojo::BindingSet<test::mojom::ConnectTestService> bindings_;
+  mojo::BindingSet<test::mojom::StandaloneApp> standalone_bindings_;
+  mojo::BindingSet<test::mojom::BlockedInterface> blocked_bindings_;
+  mojo::BindingSet<test::mojom::UserIdTest> user_id_test_bindings_;
   test::mojom::ExposedInterfacePtr caller_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectTestApp);
 };
 
 }  // namespace shell
-}  // namespace mojo
-
 
 MojoResult MojoMain(MojoHandle shell_handle) {
-  MojoResult rv = mojo::ApplicationRunner(
-      new mojo::shell::ConnectTestApp).Run(shell_handle);
+  MojoResult rv =
+      shell::ApplicationRunner(new shell::ConnectTestApp).Run(shell_handle);
   return rv;
 }