Update some uses of char16 to use the base:: namespace.

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 272 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,
     DWORD creation_flags,
-    const char16* desktop_name) {
+    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;
     BOOL use_default_token;
     HANDLE token;
@@ skipping 62 matching lines @@
 }
 
 // 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,
     DWORD creation_flags,
-    const char16* desktop_name,
+    const base::char16* desktop_name,
     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)) {
@@ skipping 62 matching lines @@
   return true;
 }
 
 bool LaunchProcessWithToken(const base::FilePath& binary,
                             const CommandLine::StringType& command_line,
                             HANDLE user_token,
                             SECURITY_ATTRIBUTES* process_attributes,
                             SECURITY_ATTRIBUTES* thread_attributes,
                             bool inherit_handles,
                             DWORD creation_flags,
-                            const char16* desktop_name,
+                            const base::char16* desktop_name,
                             ScopedHandle* process_out,
                             ScopedHandle* thread_out) {
   base::FilePath::StringType application_name = binary.value();
 
   STARTUPINFOW startup_info;
   memset(&startup_info, 0, sizeof(startup_info));
   startup_info.cb = sizeof(startup_info);
   if (desktop_name)
-    startup_info.lpDesktop = const_cast<char16*>(desktop_name);
+    startup_info.lpDesktop = const_cast<base::char16*>(desktop_name);
 
   PROCESS_INFORMATION temp_process_info = {};
   BOOL result = CreateProcessAsUser(user_token,
                                     application_name.c_str(),
                                     const_cast<LPWSTR>(command_line.c_str()),
                                     process_attributes,
                                     thread_attributes,
                                     inherit_handles,
                                     creation_flags,
                                     NULL,
@@ skipping 39 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