Move shell service to toplevel shell namespace

services/shell/tests/lifecycle/lifecycle_unittest.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/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/process/process.h"
 #include "base/run_loop.h"
 #include "services/shell/public/cpp/identity.h"
 #include "services/shell/public/cpp/shell_test.h"
 #include "services/shell/public/interfaces/shell.mojom.h"
 #include "services/shell/tests/lifecycle/lifecycle_unittest.mojom.h"
 #include "services/shell/tests/util.h"
 
-namespace mojo {
 namespace shell {
+
 namespace {
 
 const char kTestAppName[] = "mojo:lifecycle_unittest_app";
 const char kTestParentName[] = "mojo:lifecycle_unittest_parent";
 const char kTestExeName[] = "exe:lifecycle_unittest_exe";
 const char kTestPackageName[] = "mojo:lifecycle_unittest_package";
 const char kTestPackageAppNameA[] = "mojo:lifecycle_unittest_package_app_a";
 const char kTestPackageAppNameB[] = "mojo:lifecycle_unittest_package_app_b";
 const char kTestName[] = "mojo:lifecycle_unittest";
 
 void QuitLoop(base::RunLoop* loop) {
   loop->Quit();
 }
 
 void DecrementCountAndQuitWhenZero(base::RunLoop* loop, size_t* count) {
   if (!--(*count))
     loop->Quit();
 }
 
 struct Instance {
-  Instance() : id(shell::mojom::kInvalidInstanceID), pid(0) {}
+  Instance() : id(mojom::kInvalidInstanceID), pid(0) {}
   Instance(const Identity& identity, uint32_t id, uint32_t pid)
       : identity(identity), id(id), pid(pid) {}
 
   Identity identity;
   uint32_t id;
   uint32_t pid;
 };
 
 class InstanceState : public mojom::InstanceListener {
  public:
@@ skipping 10 matching lines @@
   void WaitForInstanceDestruction(base::RunLoop* loop) {
     DCHECK(!destruction_loop_);
     destruction_loop_ = loop;
     // First of all check to see if we should be spinning this loop at all -
     // the app(s) we're waiting on quitting may already have quit.
     TryToQuitDestructionLoop();
   }
 
  private:
   // mojom::InstanceListener:
-  void SetExistingInstances(Array<mojom::InstanceInfoPtr> instances) override {
+  void SetExistingInstances(
+      mojo::Array<mojom::InstanceInfoPtr> instances) override {
     for (const auto& instance : instances) {
       Instance i(instance->identity.To<Identity>(), instance->id,
                  instance->pid);
       initial_instances_[i.identity.name()] = i;
       instances_[i.identity.name()] = i;
     }
     loop_->Quit();
   }
   void InstanceCreated(mojom::InstanceInfoPtr instance) override {
     instances_[instance->identity->name] =
@@ skipping 23 matching lines @@
       destruction_loop_->Quit();
       destruction_loop_ = nullptr;
     }
   }
 
   // All currently running instances.
   std::map<std::string, Instance> instances_;
   // The initial set of instances.
   std::map<std::string, Instance> initial_instances_;
 
-  Binding<mojom::InstanceListener> binding_;
+  mojo::Binding<mojom::InstanceListener> binding_;
   base::RunLoop* loop_;
 
   // Set when the client wants to wait for this object to track the destruction
   // of an instance before proceeding.
   base::RunLoop* destruction_loop_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceState);
 };
 
-}
+}  // namespace
 
-class LifecycleTest : public mojo::test::ShellTest {
+class LifecycleTest : public test::ShellTest {
  public:
   LifecycleTest() : ShellTest(kTestName) {}
   ~LifecycleTest() override {}
 
  protected:
-  // mojo::test::ShellTest:
+  // test::ShellTest:
   void SetUp() override {
-    mojo::test::ShellTest::SetUp();
+    test::ShellTest::SetUp();
     InitPackage();
     instances_ = TrackInstances();
   }
   void TearDown() override {
     instances_.reset();
-    mojo::test::ShellTest::TearDown();
+    test::ShellTest::TearDown();
   }
 
   bool CanRunCrashTest() {
     return !base::CommandLine::ForCurrentProcess()->HasSwitch("single-process");
   }
 
   void InitPackage() {
     test::mojom::LifecycleControlPtr lifecycle = ConnectTo(kTestPackageName);
     base::RunLoop loop;
     lifecycle.set_connection_error_handler(base::Bind(&QuitLoop, &loop));
@@ skipping 30 matching lines @@
 
   InstanceState* instances() { return instances_.get(); }
 
   void WaitForInstanceDestruction() {
     base::RunLoop loop;
     instances()->WaitForInstanceDestruction(&loop);
     loop.Run();
   }
 
  private:
-  scoped_ptr<InstanceState> TrackInstances() {
+  std::unique_ptr<InstanceState> TrackInstances() {
     mojom::ShellPtr shell;
     connector()->ConnectToInterface("mojo:shell", &shell);
     mojom::InstanceListenerPtr listener;
     base::RunLoop loop;
     InstanceState* state = new InstanceState(GetProxy(&listener), &loop);
     shell->AddInstanceListener(std::move(listener));
     loop.Run();
-    return make_scoped_ptr(state);
+    return base::WrapUnique(state);
   }
 
-  scoped_ptr<InstanceState> instances_;
+  std::unique_ptr<InstanceState> instances_;
 
   DISALLOW_COPY_AND_ASSIGN(LifecycleTest);
 };
 
 TEST_F(LifecycleTest, Standalone_GracefulQuit) {
   test::mojom::LifecycleControlPtr lifecycle = ConnectTo(kTestAppName);
 
   EXPECT_TRUE(instances()->HasInstanceForName(kTestAppName));
   EXPECT_EQ(1u, instances()->GetNewInstanceCount());
 
@@ skipping 222 matching lines @@
   process.Terminate(9, true);
   loop.Run();
 
   WaitForInstanceDestruction();
   EXPECT_FALSE(instances()->HasInstanceForName(kTestExeName));
   EXPECT_EQ(0u, instances()->GetNewInstanceCount());
 }
 
 TEST_F(LifecycleTest, ShutdownTree) {
   // Verifies that Instances are destroyed when their creator is.
-  scoped_ptr<Connection> parent_connection =
+  std::unique_ptr<Connection> parent_connection =
       connector()->Connect(kTestParentName);
   test::mojom::ParentPtr parent;
   parent_connection->GetInterface(&parent);
 
   // This asks kTestParentName to open a connection to kTestAppName and blocks
   // on a response from a Ping().
   {
     base::RunLoop loop;
     parent->ConnectToChild(base::Bind(&QuitLoop, &loop));
     loop.Run();
   }
 
   // Should now have two new instances (parent and child).
   EXPECT_EQ(2u, instances()->GetNewInstanceCount());
   EXPECT_TRUE(instances()->HasInstanceForName(kTestParentName));
   EXPECT_TRUE(instances()->HasInstanceForName(kTestAppName));
 
   parent->Quit();
 
   // Quitting the parent should cascade-quit the child.
   WaitForInstanceDestruction();
   EXPECT_EQ(0u, instances()->GetNewInstanceCount());
   EXPECT_FALSE(instances()->HasInstanceForName(kTestParentName));
   EXPECT_FALSE(instances()->HasInstanceForName(kTestAppName));
 }
 
 }  // namespace shell
-}  // namespace mojo