Avoiding unnecessary conversion to UTF16 in runtime.

remoting/host/host_service_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/host_service_win.h"
 
 #include <windows.h>
 #include <wtsapi32.h>
 #include <stdio.h>
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
+#include "base/stringize_macros.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
-#include "base/utf_string_conversions.h"
 #include "base/win/wrapped_window_proc.h"
 
 #include "remoting/base/scoped_sc_handle_win.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/host_service_resource.h"
 #include "remoting/host/wts_console_observer_win.h"
 #include "remoting/host/wts_session_process_launcher_win.h"
 
 using base::StringPrintf;
 
 namespace {
 
 // TODO(alexeypa): investigate and migrate this over to Chrome's i18n framework.
-const char kMuiStringFormat[] = "@%ls,-%d";
-const char kServiceDependencies[] = "";
+const char16 kMuiStringFormat[] = TO_L_STRING("@%ls,-%d");
+const char16 kServiceDependencies[] = TO_L_STRING("");
 
-const char kServiceCommandLineFormat[] = "\"%ls\" --host-binary=\"%ls\"";
+const char16 kServiceCommandLineFormat[] =
+    TO_L_STRING("\"%ls\" --host-binary=\"%ls\"");
 
 const DWORD kServiceStopTimeoutMs = 30 * 1000;
 
 // Session id that does not represent any session.
 const uint32 kInvalidSession = 0xffffffff;
 
 const char kIoThreadName[] = "I/O thread";
 
 // A window class for the session change notifications window.
-static const char kSessionNotificationWindowClass[] =
-  "Chromoting_SessionNotificationWindow";
+const char16 kSessionNotificationWindowClass[] =
+  TO_L_STRING("Chromoting_SessionNotificationWindow");
 
 // Command line actions and switches:
 // "run" sumply runs the service as usual.
-const char kRunActionName[] = "run";
+const char16 kRunActionName[] = TO_L_STRING("run");
 
 // "install" requests the service to be installed.
-const char kInstallActionName[] = "install";
+const char16 kInstallActionName[] = TO_L_STRING("install");
 
 // "remove" uninstalls the service.
-const char kRemoveActionName[] = "remove";
+const char16 kRemoveActionName[] = TO_L_STRING("remove");
 
 // "--console" runs the service interactively for debugging purposes.
 const char kConsoleSwitchName[] = "console";
 
 // "--host-binary" specifies the host binary to run in console session.
 const char kHostBinarySwitchName[] = "host-binary";
 
 // "--help" or "--?" prints the usage message.
 const char kHelpSwitchName[] = "help";
 const char kQuestionSwitchName[] = "?";
@@ skipping 22 matching lines @@
 }
 
 }  // namespace
 
 namespace remoting {
 
 HostService::HostService() :
   console_session_id_(kInvalidSession),
   message_loop_(NULL),
   run_routine_(&HostService::RunAsService),
-  service_name_(UTF8ToUTF16(kWindowsServiceName)),
+  service_name_(kWindowsServiceName),
   service_status_handle_(0),
   shutting_down_(false),
   stopped_event_(true, false) {
 }
 
 HostService::~HostService() {
 }
 
 void HostService::AddWtsConsoleObserver(WtsConsoleObserver* observer) {
   DCHECK(message_loop_->message_loop_proxy()->BelongsToCurrentThread());
@@ skipping 63 matching lines @@
 bool HostService::InitWithCommandLine(const CommandLine* command_line) {
   CommandLine::StringVector args = command_line->GetArgs();
 
   // Choose the action to perform.
   bool host_binary_required = true;
   if (!args.empty()) {
     if (args.size() > 1) {
       LOG(ERROR) << "Invalid command line: more than one action requested.";
       return false;
     }
-    if (args[0] == ASCIIToUTF16(kInstallActionName)) {
+    if (args[0] == kInstallActionName) {
       run_routine_ = &HostService::Install;
-    } else if (args[0] == ASCIIToUTF16(kRemoveActionName)) {
+    } else if (args[0] == kRemoveActionName) {
       run_routine_ = &HostService::Remove;
       host_binary_required = false;
-    } else if (args[0] != ASCIIToUTF16(kRunActionName)) {
+    } else if (args[0] != kRunActionName) {
       LOG(ERROR) << "Invalid command line: invalid action specified: "
                  << args[0];
       return false;
     }
   }
 
   if (host_binary_required) {
     if (command_line->HasSwitch(kHostBinarySwitchName)) {
       host_binary_ = command_line->GetSwitchValuePath(kHostBinarySwitchName);
     } else {
@@ skipping 21 matching lines @@
         << "Failed to connect to the service control manager";
     return kErrorExitCode;
   }
 
   FilePath exe;
   if (!PathService::Get(base::FILE_EXE, &exe)) {
     LOG(ERROR) << "Unable to retrieve the service binary path.";
     return kErrorExitCode;
   }
 
-  string16 name = StringPrintf(ASCIIToUTF16(kMuiStringFormat).c_str(),
+  string16 name = StringPrintf(kMuiStringFormat,
                                exe.value().c_str(),
                                IDS_DISPLAY_SERVICE_NAME);
 
   if (!file_util::AbsolutePath(&host_binary_) ||
       !file_util::PathExists(host_binary_)) {
     LOG(ERROR) << "Invalid host binary name: " << host_binary_.value();
     return kErrorExitCode;
   }
 
-  string16 command_line = StringPrintf(
-                              ASCIIToUTF16(kServiceCommandLineFormat).c_str(),
-                              exe.value().c_str(),
-                              host_binary_.value().c_str());
+  string16 command_line = StringPrintf(kServiceCommandLineFormat,
+                                       exe.value().c_str(),
+                                       host_binary_.value().c_str());
   ScopedScHandle service(
       CreateServiceW(scmanager,
                      service_name_.c_str(),
                      name.c_str(),
                      SERVICE_QUERY_STATUS | SERVICE_CHANGE_CONFIG,
                      SERVICE_WIN32_OWN_PROCESS,
                      SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
                      command_line.c_str(),
                      NULL,
                      NULL,
-                     ASCIIToUTF16(kServiceDependencies).c_str(),
+                     kServiceDependencies,
                      NULL,
                      NULL));
 
   if (service.IsValid()) {
     // Set the service description if the service is freshly installed.
-    string16 description = StringPrintf(
-                               ASCIIToUTF16(kMuiStringFormat).c_str(),
-                               exe.value().c_str(),
-                               IDS_SERVICE_DESCRIPTION);
+    string16 description = StringPrintf(kMuiStringFormat,
+                                        exe.value().c_str(),
+                                        IDS_SERVICE_DESCRIPTION);
 
     SERVICE_DESCRIPTIONW info;
     info.lpDescription = const_cast<LPWSTR>(description.c_str());
     if (!ChangeServiceConfig2W(service, SERVICE_CONFIG_DESCRIPTION, &info)) {
       LOG_GETLASTERROR(ERROR) << "Failed to set the service description";
       return kErrorExitCode;
     }
 
     printf("The service has been installed successfully.\n");
     return kSuccessExitCode;
@@ skipping 134 matching lines @@
   if (!SetConsoleCtrlHandler(&HostService::ConsoleControlHandler, TRUE)) {
     LOG_GETLASTERROR(ERROR)
         << "Failed to set console control handler";
     return result;
   }
 
   // Create a window for receiving session change notifications.
   LPCWSTR atom = NULL;
   HWND window = NULL;
   HINSTANCE instance = GetModuleHandle(NULL);
-  string16 window_class = ASCIIToUTF16(kSessionNotificationWindowClass);
 
   WNDCLASSEX wc = {0};
   wc.cbSize = sizeof(wc);
   wc.lpfnWndProc = base::win::WrappedWindowProc<SessionChangeNotificationProc>;
   wc.hInstance = instance;
-  wc.lpszClassName = window_class.c_str();
+  wc.lpszClassName = kSessionNotificationWindowClass;
   atom = reinterpret_cast<LPCWSTR>(RegisterClassExW(&wc));
   if (atom == NULL) {
     LOG_GETLASTERROR(ERROR)
         << "Failed to register the window class '"
         << kSessionNotificationWindowClass << "'";
     goto cleanup;
   }
 
   window = CreateWindowW(atom, 0, 0, 0, 0, 0, 0, HWND_MESSAGE, 0, instance, 0);
   if (window == NULL) {
@@ skipping 158 matching lines @@
   }
 
   remoting::HostService* service = remoting::HostService::GetInstance();
   if (!service->InitWithCommandLine(command_line)) {
     usage(argv[0]);
     return kUsageExitCode;
   }
 
   return service->Run();
 }