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

remoting/host/win/wts_session_process_launcher.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_launcher.h"
 
 #include <windows.h>
 #include <sddl.h>
 #include <limits>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
+#include "base/utf_string_conversions.h"
 #include "base/win/scoped_handle.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/host/constants.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/sas_injector.h"
 #include "remoting/host/win/launch_process_with_token.h"
 #include "remoting/host/win/wts_console_monitor.h"
 
 using base::win::ScopedHandle;
 using base::TimeDelta;
 
 namespace {
 
 // The minimum and maximum delays between attempts to inject host process into
 // a session.
 const int kMaxLaunchDelaySeconds = 60;
 const int kMinLaunchDelaySeconds = 1;
 
 const FilePath::CharType kMe2meHostBinaryName[] =
     FILE_PATH_LITERAL("remoting_me2me_host.exe");
 
 // Match the pipe name prefix used by Chrome IPC channels.
-const wchar_t kChromePipeNamePrefix[] = L"\\\\.\\pipe\\chrome.";
+const char kChromePipeNamePrefix[] = "\\\\.\\pipe\\chrome.";
 
 // The IPC channel name is passed to the host in the command line.
 const char kChromotingIpcSwitchName[] = "chromoting-ipc";
 
 // The command line parameters that should be copied from the service's command
 // line to the host process.
 const char* kCopiedSwitchNames[] = {
     "auth-config", "host-config", switches::kV, switches::kVModule };
 
 // The security descriptor of the Chromoting IPC channel. It gives full access
@@ skipping 82 matching lines @@
         "Failed to change session ID of a token";
     return false;
   }
 
   token_out->Set(session_token.Take());
   return true;
 }
 
 // Generates random channel ID.
 // N.B. Stolen from src/content/common/child_process_host_impl.cc
-std::wstring GenerateRandomChannelId(void* instance) {
-  return base::StringPrintf(L"%d.%p.%d",
+std::string GenerateRandomChannelId(void* instance) {
+  return base::StringPrintf("%d.%p.%d",
                             base::GetCurrentProcId(), instance,
                             base::RandInt(0, std::numeric_limits<int>::max()));
 }
 
 // Creates the server end of the Chromoting IPC channel.
 // N.B. This code is based on IPC::Channel's implementation.
 bool CreatePipeForIpcChannel(void* instance,
-                             std::wstring* channel_name_out,
+                             std::string* channel_name_out,
                              ScopedHandle* pipe_out) {
   // Create security descriptor for the channel.
   SECURITY_ATTRIBUTES security_attributes;
   security_attributes.nLength = sizeof(security_attributes);
   security_attributes.bInheritHandle = FALSE;
 
   ULONG security_descriptor_length = 0;
   if (!ConvertStringSecurityDescriptorToSecurityDescriptorW(
            kChromotingChannelSecurityDescriptor,
            SDDL_REVISION_1,
            reinterpret_cast<PSECURITY_DESCRIPTOR*>(
                &security_attributes.lpSecurityDescriptor),
            &security_descriptor_length)) {
     LOG_GETLASTERROR(ERROR) <<
         "Failed to create a security descriptor for the Chromoting IPC channel";
     return false;
   }
 
   // Generate a random channel name.
-  std::wstring channel_name(GenerateRandomChannelId(instance));
+  std::string channel_name(GenerateRandomChannelId(instance));
 
   // Convert it to the pipe name.
-  std::wstring pipe_name(kChromePipeNamePrefix);
+  std::string pipe_name(kChromePipeNamePrefix);
   pipe_name.append(channel_name);
 
   // Create the server end of the pipe. This code should match the code in
   // IPC::Channel with exception of passing a non-default security descriptor.
-  HANDLE pipe = CreateNamedPipeW(pipe_name.c_str(),
+  HANDLE pipe = CreateNamedPipeW(UTF8ToUTF16(pipe_name).c_str(),
                                  PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED |
                                      FILE_FLAG_FIRST_PIPE_INSTANCE,
                                  PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,
                                  1,
                                  IPC::Channel::kReadBufferSize,
                                  IPC::Channel::kReadBufferSize,
                                  5000,
                                  &security_attributes);
   if (pipe == INVALID_HANDLE_VALUE) {
     LOG_GETLASTERROR(ERROR) <<
@@ skipping 51 matching lines @@
 
   // Construct the host binary name.
   FilePath dir_path;
   if (!PathService::Get(base::DIR_EXE, &dir_path)) {
     LOG(ERROR) << "Failed to get the executable file name.";
     Stop();
     return;
   }
   FilePath host_binary = dir_path.Append(kMe2meHostBinaryName);
 
-  std::wstring channel_name;
+  std::string channel_name;
   ScopedHandle pipe;
   if (CreatePipeForIpcChannel(this, &channel_name, &pipe)) {
     // Wrap the pipe into an IPC channel.
     chromoting_channel_.reset(new IPC::ChannelProxy(
         IPC::ChannelHandle(pipe.Get()),
         IPC::Channel::MODE_SERVER,
         this,
         ipc_message_loop_));
 
     // Create the host process command line passing the name of the IPC channel
     // to use and copying known switches from the service's command line.
     CommandLine command_line(host_binary);
-    command_line.AppendSwitchNative(kChromotingIpcSwitchName, channel_name);
+    command_line.AppendSwitchASCII(kChromotingIpcSwitchName, channel_name);
     command_line.CopySwitchesFrom(*CommandLine::ForCurrentProcess(),
                                   kCopiedSwitchNames,
                                   _countof(kCopiedSwitchNames));
 
     // Try to launch the process and attach an object watcher to the returned
     // handle so that we get notified when the process terminates.
     if (LaunchProcessWithToken(host_binary,
                                command_line.GetCommandLineString(),
                                session_token_,
                                &process_)) {
@@ skipping 193 matching lines @@
 
 void WtsSessionProcessLauncher::DoStop() {
   if (state_ != StateDetached) {
     OnSessionDetached();
   }
 
   CompleteStopping();
 }
 
 } // namespace remoting