Make callers of CommandLine use it via the base:: namespace.

remoting/host/win/wts_session_process_delegate.cc

 // Copyright (c) 2012 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.
 //
 // This file implements the Windows service controlling Me2Me host processes
 // running within user sessions.
 
 #include "remoting/host/win/wts_session_process_delegate.h"
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 
 // A private class actually implementing the functionality provided by
 // |WtsSessionProcessDelegate|. This class is ref-counted and implements
 // asynchronous fire-and-forget shutdown.
 class WtsSessionProcessDelegate::Core
     : public base::RefCountedThreadSafe<Core>,
       public base::MessagePumpForIO::IOHandler,
       public IPC::Listener {
  public:
   Core(scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-       scoped_ptr<CommandLine> target,
+       scoped_ptr<base::CommandLine> target,
        bool launch_elevated,
        const std::string& channel_security);
 
   // Initializes the object returning true on success.
   bool Initialize(uint32 session_id);
 
   // Stops the object asynchronously.
   void Stop();
 
   // Mirrors WorkerProcessLauncher::Delegate.
@@ skipping 67 matching lines @@
   // True if a laucnh attemp is pending.
   bool launch_pending_;
 
   // The named pipe used as the transport by |channel_|.
   base::win::ScopedHandle pipe_;
 
   // The token to be used to launch a process in a different session.
   base::win::ScopedHandle session_token_;
 
   // Command line of the launched process.
-  scoped_ptr<CommandLine> target_command_;
+  scoped_ptr<base::CommandLine> target_command_;
 
   // The handle of the worker process, if launched.
   base::win::ScopedHandle worker_process_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 WtsSessionProcessDelegate::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-    scoped_ptr<CommandLine> target_command,
+    scoped_ptr<base::CommandLine> target_command,
     bool launch_elevated,
     const std::string& channel_security)
     : caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_task_runner_(io_task_runner),
       channel_security_(channel_security),
       event_handler_(NULL),
       get_named_pipe_client_pid_(NULL),
       launch_elevated_(launch_elevated),
       launch_pending_(false),
       target_command_(target_command.Pass()) {
@@ skipping 366 matching lines @@
     ReportFatalError();
     return;
   }
   ScopedHandle limited_handle(temp_handle);
 
   event_handler_->OnProcessLaunched(limited_handle.Pass());
 }
 
 WtsSessionProcessDelegate::WtsSessionProcessDelegate(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-    scoped_ptr<CommandLine> target_command,
+    scoped_ptr<base::CommandLine> target_command,
     bool launch_elevated,
     const std::string& channel_security) {
   core_ = new Core(io_task_runner,
                    target_command.Pass(),
                    launch_elevated,
                    channel_security);
 }
 
 WtsSessionProcessDelegate::~WtsSessionProcessDelegate() {
   core_->Stop();
@@ skipping 14 matching lines @@
 
 void WtsSessionProcessDelegate::CloseChannel() {
   core_->CloseChannel();
 }
 
 void WtsSessionProcessDelegate::KillProcess() {
   core_->KillProcess();
 }
 
 }  // namespace remoting