Cleaned up usage of std::wstring in src/remoting. Added presubmit warning supressions for the reman…

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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_native_library.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_process_information.h"
 #include "base/win/windows_version.h"
 
 using base::win::ScopedHandle;
 
 namespace {
 
-const wchar_t kCreateProcessDefaultPipeNameFormat[] =
-    L"\\\\.\\Pipe\\TerminalServer\\SystemExecSrvr\\%d";
+const char kCreateProcessDefaultPipeNameFormat[] =
+    "\\\\.\\Pipe\\TerminalServer\\SystemExecSrvr\\%d";
 
 // Undocumented WINSTATIONINFOCLASS value causing
 // winsta!WinStationQueryInformationW() to return the name of the pipe for
 // requesting cross-session process creation.
 const WINSTATIONINFOCLASS kCreateProcessPipeNameClass =
     static_cast<WINSTATIONINFOCLASS>(0x21);
 
 const int kPipeBusyWaitTimeoutMs = 2000;
 const int kPipeConnectMaxAttempts = 3;
 
 // The minimum and maximum delays between attempts to inject host process into
 // a session.
 const int kMaxLaunchDelaySeconds = 60;
 const int kMinLaunchDelaySeconds = 1;
 
 // Name of the default session desktop.
-wchar_t kDefaultDesktopName[] = L"winsta0\\default";
+const char kDefaultDesktopName[] = "winsta0\\default";
 
 // 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 std::wstring& application_name,
-    const std::wstring& command_line,
+    const FilePath::StringType& application_name,
+    const CommandLine::StringType& command_line,
     PROCESS_INFORMATION* process_information_out)
 {
   DCHECK(base::win::GetVersion() == base::win::VERSION_XP);
 
-  std::wstring pipe_name;
+  string16 pipe_name;
 
   // Use winsta!WinStationQueryInformationW() to determine the process creation
   // pipe name for the session.
   FilePath winsta_path(base::GetNativeLibraryName(UTF8ToUTF16("winsta")));
   base::ScopedNativeLibrary winsta(winsta_path);
   if (winsta.is_valid()) {
     PWINSTATIONQUERYINFORMATIONW win_station_query_information =
         static_cast<PWINSTATIONQUERYINFORMATIONW>(
             winsta.GetFunctionPointer("WinStationQueryInformationW"));
     if (win_station_query_information) {
       wchar_t name[MAX_PATH];
       ULONG name_length;
       if (win_station_query_information(0,
                                         session_id,
                                         kCreateProcessPipeNameClass,
                                         name,
                                         sizeof(name),
                                         &name_length)) {
         pipe_name.assign(name);
       }
     }
   }
 
   // Use the default pipe name if we couldn't query its name.
   if (pipe_name.empty()) {
-    pipe_name = StringPrintf(kCreateProcessDefaultPipeNameFormat, session_id);
+    pipe_name = UTF8ToUTF16(
+        StringPrintf(kCreateProcessDefaultPipeNameFormat, session_id));
   }
 
   // Try to connect to the named pipe.
   base::win::ScopedHandle pipe;
   for (int i = 0; i < kPipeConnectMaxAttempts; ++i) {
     pipe.Set(CreateFile(pipe_name.c_str(),
                         GENERIC_READ | GENERIC_WRITE,
                         0,
                         NULL,
                         OPEN_EXISTING,
@@ skipping 13 matching lines @@
     if (!WaitNamedPipe(pipe_name.c_str(), kPipeBusyWaitTimeoutMs)) {
       break;
     }
   }
 
   if (!pipe.IsValid()) {
     LOG_GETLASTERROR(ERROR) << "Failed to connect to '" << pipe_name << "'";
     return false;
   }
 
-  std::wstring desktop_name(kDefaultDesktopName);
+  string16 desktop_name(UTF8ToUTF16(kDefaultDesktopName));
 
   // |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;
     BOOL use_default_token;
@@ skipping 112 matching lines @@
 
   *process_information_out = response.process_information;
   return true;
 }
 
 } // namespace
 
 namespace remoting {
 
 bool LaunchProcessWithToken(const FilePath& binary,
-                            const std::wstring& command_line,
+                            const CommandLine::StringType& command_line,
                             HANDLE user_token,
                             base::Process* process_out) {
-  std::wstring application_name = binary.value();
+  FilePath::StringType application_name = binary.value();
 
   base::win::ScopedProcessInformation process_info;
   STARTUPINFOW startup_info;
 
+  string16 desktop_name(UTF8ToUTF16(kDefaultDesktopName));
+
   memset(&startup_info, 0, sizeof(startup_info));
   startup_info.cb = sizeof(startup_info);
-  startup_info.lpDesktop = kDefaultDesktopName;
+  startup_info.lpDesktop = const_cast<char16*>(desktop_name.c_str());
 
   BOOL result = CreateProcessAsUser(user_token,
                                     application_name.c_str(),
                                     const_cast<LPWSTR>(command_line.c_str()),
                                     NULL,
                                     NULL,
                                     FALSE,
                                     0,
                                     NULL,
                                     NULL,
@@ skipping 33 matching lines @@
         "Failed to launch a process with a user token";
     return false;
   }
 
   CHECK(process_info.IsValid());
   process_out->set_handle(process_info.TakeProcessHandle());
   return true;
 }
 
 } // namespace remoting