Move shell service to toplevel shell namespace

services/shell/runner/host/child_process_host.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/runner/host/child_process_host.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 20 matching lines @@
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "services/shell/runner/host/mach_broker.h"
 #endif
 
-namespace mojo {
 namespace shell {
 
 ChildProcessHost::ChildProcessHost(base::TaskRunner* launch_process_runner,
                                    NativeRunnerDelegate* delegate,
                                    bool start_sandboxed,
                                    const Identity& target,
                                    const base::FilePath& app_path)
     : launch_process_runner_(launch_process_runner),
       delegate_(delegate),
       start_sandboxed_(start_sandboxed),
@@ skipping 18 matching lines @@
 
   const base::CommandLine* parent_command_line =
       base::CommandLine::ForCurrentProcess();
   base::FilePath target_path = parent_command_line->GetProgram();
   // |app_path_| can be empty in tests.
   if (!app_path_.MatchesExtension(FILE_PATH_LITERAL(".mojo")) &&
       !app_path_.empty()) {
     target_path = app_path_;
   }
 
-  scoped_ptr<base::CommandLine> child_command_line(
+  std::unique_ptr<base::CommandLine> child_command_line(
       new base::CommandLine(target_path));
 
   child_command_line->AppendArguments(*parent_command_line, false);
 
 #ifndef NDEBUG
   child_command_line->AppendSwitchASCII("n", target.name());
   child_command_line->AppendSwitchASCII("u", target.user_id());
 #endif
 
   if (target_path != app_path_)
     child_command_line->AppendSwitchPath(switches::kChildProcess, app_path_);
 
   if (start_sandboxed_)
     child_command_line->AppendSwitch(switches::kEnableSandbox);
 
-  mojo_ipc_channel_.reset(new edk::PlatformChannelPair);
+  mojo_ipc_channel_.reset(new mojo::edk::PlatformChannelPair);
   mojo_ipc_channel_->PrepareToPassClientHandleToChildProcess(
       child_command_line.get(), &handle_passing_info_);
 
   mojom::ShellClientPtr client =
       PassShellClientRequestOnCommandLine(child_command_line.get());
   launch_process_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&ChildProcessHost::DoLaunch, base::Unretained(this),
                  base::Passed(&child_command_line)),
       base::Bind(&ChildProcessHost::DidStart,
@@ skipping 16 matching lines @@
 void ChildProcessHost::DidStart(const ProcessReadyCallback& callback) {
   if (child_process_.IsValid()) {
     callback.Run(child_process_.Pid());
   } else {
     LOG(ERROR) << "Failed to start child process";
     mojo_ipc_channel_.reset();
   }
 }
 
 void ChildProcessHost::DoLaunch(
-    scoped_ptr<base::CommandLine> child_command_line) {
+    std::unique_ptr<base::CommandLine> child_command_line) {
   if (delegate_) {
     delegate_->AdjustCommandLineArgumentsForTarget(target_,
                                                    child_command_line.get());
   }
 
   base::LaunchOptions options;
 #if defined(OS_WIN)
   options.handles_to_inherit = &handle_passing_info_;
 #if defined(OFFICIAL_BUILD)
   CHECK(false) << "Launching mojo process with inherit_handles is insecure!";
@@ skipping 58 matching lines @@
       mojo::edk::ChildProcessLaunched(
           child_process_.Handle(),
           mojo::edk::ScopedPlatformHandle(mojo::edk::PlatformHandle(
               mojo_ipc_channel_->PassServerHandle().release().handle)));
     }
   }
   start_child_process_event_.Signal();
 }
 
 }  // namespace shell
-}  // namespace mojo