Cleanup: Use base::CommandLine in remoting/

remoting/host/win/launch_process_with_token.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.
 
 #include "remoting/host/win/launch_process_with_token.h"
 
 #include <windows.h>
 #include <winternl.h>
 
 #include <limits>
@@ skipping 269 matching lines @@
   }
 
   *process_information_out = response.process_information;
   return true;
 }
 
 // Sends a remote process create request to the execution server.
 bool SendCreateProcessRequest(
     HANDLE pipe,
     const base::FilePath::StringType& application_name,
-    const CommandLine::StringType& command_line,
+    const base::CommandLine::StringType& command_line,
     DWORD creation_flags,
     const base::char16* desktop_name) {
   // |CreateProcessRequest| structure passes the same parameters to
   // the execution server as CreateProcessAsUser() function does. Strings are
   // stored as wide strings immediately after the structure. String pointers are
   // represented as byte offsets to string data from the beginning of
   // the structure.
   struct CreateProcessRequest {
     DWORD size;
     DWORD process_id;
@@ skipping 62 matching lines @@
 
   return true;
 }
 
 // Requests the execution server to create a process in the specified session
 // using the default (i.e. Winlogon) token. This routine relies on undocumented
 // OS functionality and will likely not work on anything but XP or W2K3.
 bool CreateRemoteSessionProcess(
     uint32 session_id,
     const base::FilePath::StringType& application_name,
-    const CommandLine::StringType& command_line,
+    const base::CommandLine::StringType& command_line,
     DWORD creation_flags,
     const base::char16* desktop_name,
-    PROCESS_INFORMATION* process_information_out)
-{
+    PROCESS_INFORMATION* process_information_out) {
   DCHECK_LT(base::win::GetVersion(), base::win::VERSION_VISTA);
 
   base::win::ScopedHandle pipe;
   if (!ConnectToExecutionServer(session_id, &pipe))
     return false;
 
   if (!SendCreateProcessRequest(pipe, application_name, command_line,
                                 creation_flags, desktop_name)) {
     return false;
   }
 
   PROCESS_INFORMATION process_information;
   if (!ReceiveCreateProcessResponse(pipe, &process_information))
     return false;
 
   if (!ProcessCreateProcessResponse(creation_flags, &process_information)) {
     CloseHandlesAndTerminateProcess(&process_information);
     return false;
   }
 
   *process_information_out = process_information;
   return true;
 }
 
-} // namespace
+}  // namespace
 
 namespace remoting {
 
 base::LazyInstance<base::Lock>::Leaky g_inherit_handles_lock =
     LAZY_INSTANCE_INITIALIZER;
 
 // Creates a copy of the current process token for the given |session_id| so
 // it can be used to launch a process in that session.
 bool CreateSessionToken(uint32 session_id, ScopedHandle* token_out) {
   ScopedHandle session_token;
@@ skipping 28 matching lines @@
   }
 
   // Revert to the default token.
   CHECK(RevertToSelf());
 
   *token_out = session_token.Pass();
   return true;
 }
 
 bool LaunchProcessWithToken(const base::FilePath& binary,
-                            const CommandLine::StringType& command_line,
+                            const base::CommandLine::StringType& command_line,
                             HANDLE user_token,
                             SECURITY_ATTRIBUTES* process_attributes,
                             SECURITY_ATTRIBUTES* thread_attributes,
                             bool inherit_handles,
                             DWORD creation_flags,
                             const base::char16* desktop_name,
                             ScopedHandle* process_out,
                             ScopedHandle* thread_out) {
   base::FilePath::StringType application_name = binary.value();
 
@@ skipping 52 matching lines @@
   }
 
   base::win::ScopedProcessInformation process_info(temp_process_info);
 
   CHECK(process_info.IsValid());
   process_out->Set(process_info.TakeProcessHandle());
   thread_out->Set(process_info.TakeThreadHandle());
   return true;
 }
 
-} // namespace remoting
+}  // namespace remoting