Avoiding unnecessary conversion to UTF16 in runtime.

remoting/host/wts_session_process_launcher_win.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/wts_session_process_launcher_win.h"
 
 #include <windows.h>
 #include <sddl.h>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/string16.h"
+#include "base/stringize_macros.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 "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/sas_injector.h"
 #include "remoting/host/wts_console_monitor_win.h"
 
 using base::win::ScopedHandle;
 using base::TimeDelta;
 
 namespace {
 
 // The exit code returned by the host process when its configuration is not
 // valid.
 const int kInvalidHostConfigurationExitCode = 1;
 
 // 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.
-const char kDefaultDesktopName[] = "winsta0\\default";
+char16 kDefaultDesktopName[] = TO_L_STRING("winsta0\\default");
 
 // Match the pipe name prefix used by Chrome IPC channels.
-const char kChromePipeNamePrefix[] = "\\\\.\\pipe\\chrome.";
+const char16 kChromePipeNamePrefix[] = TO_L_STRING("\\\\.\\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" };
 
 // The security descriptor of the Chromoting IPC channel. It gives full access
 // to LocalSystem and denies access by anyone else.
-const char kChromotingChannelSecurityDescriptor[] =
-    "O:SY" "G:SY" "D:(A;;GA;;;SY)";
+const char16 kChromotingChannelSecurityDescriptor[] =
+    TO_L_STRING("O:SYG:SYD:(A;;GA;;;SY)");
 
 // Takes the process token and makes a copy of it. The returned handle will have
 // |desired_access| rights.
 bool CopyProcessToken(DWORD desired_access,
                       ScopedHandle* token_out) {
 
   HANDLE handle;
   if (!OpenProcessToken(GetCurrentProcess(),
                         TOKEN_DUPLICATE | desired_access,
                         &handle)) {
@@ skipping 70 matching lines @@
     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
 string16 GenerateRandomChannelId(void* instance) {
-  return base::StringPrintf(ASCIIToUTF16("%d.%p.%d").c_str(),
+  return base::StringPrintf(TO_L_STRING("%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,
                              string16* 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 (!ConvertStringSecurityDescriptorToSecurityDescriptorA(
+  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.
   string16 channel_name(GenerateRandomChannelId(instance));
 
   // Convert it to the pipe name.
-  string16 pipe_name(ASCIIToUTF16(kChromePipeNamePrefix));
+  string16 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(),
                                  PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED |
                                      FILE_FLAG_FIRST_PIPE_INSTANCE,
                                  PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,
                                  1,
                                  IPC::Channel::kReadBufferSize,
@@ skipping 13 matching lines @@
   pipe_out->Set(pipe);
   return true;
 }
 
 // Launches |binary| in the security context of the supplied |user_token|.
 bool LaunchProcessAsUser(const FilePath& binary,
                          const string16& command_line,
                          HANDLE user_token,
                          base::Process* process_out) {
   string16 application_name = binary.value();
-  string16 desktop = ASCIIToUTF16(kDefaultDesktopName);
 
   base::win::ScopedProcessInformation process_info;
   STARTUPINFOW startup_info;
 
   memset(&startup_info, 0, sizeof(startup_info));
   startup_info.cb = sizeof(startup_info);
-  startup_info.lpDesktop = const_cast<LPWSTR>(desktop.c_str());
+  startup_info.lpDesktop = kDefaultDesktopName;
 
   if (!CreateProcessAsUserW(user_token,
                             application_name.c_str(),
                             const_cast<LPWSTR>(command_line.c_str()),
                             NULL,
                             NULL,
                             FALSE,
                             0,
                             NULL,
                             NULL,
@@ skipping 251 matching lines @@
       process_watcher_.StopWatching();
       process_.Terminate(0);
       process_.Close();
       chromoting_channel_.reset();
       state_ = StateDetached;
       break;
   }
 }
 
 } // namespace remoting