Switch to standard integer types in remoting/host/.

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 <stddef.h>
 #include <winternl.h>
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/scoped_native_library.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
@@ skipping 27 matching lines @@
   }
 
   if (process_information->hProcess) {
     TerminateProcess(process_information->hProcess, CONTROL_C_EXIT);
     CloseHandle(process_information->hProcess);
     process_information->hProcess = nullptr;
   }
 }
 
 // Connects to the executor server corresponding to |session_id|.
-bool ConnectToExecutionServer(uint32 session_id,
+bool ConnectToExecutionServer(uint32_t session_id,
                               base::win::ScopedHandle* pipe_out) {
   base::string16 pipe_name;
 
   // Use winsta!WinStationQueryInformationW() to determine the process creation
   // pipe name for the session.
   base::FilePath winsta_path(
       base::GetNativeLibraryName(base::UTF8ToUTF16("winsta")));
   base::ScopedNativeLibrary winsta(winsta_path);
   if (winsta.is_valid()) {
     PWINSTATIONQUERYINFORMATIONW win_station_query_information =
@@ skipping 296 matching lines @@
     return false;
   }
 
   return true;
 }
 
 // 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,
+    uint32_t session_id,
     const base::FilePath::StringType& application_name,
     const base::CommandLine::StringType& command_line,
     DWORD creation_flags,
     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;
@@ skipping 18 matching lines @@
 
 }  // namespace
 
 namespace remoting {
 
 base::LazyInstance<base::Lock>::Leaky g_inherit_handles_lock =
     LAZY_INSTANCE_INITIALIZER;
 
 // Creates a copy of the current process token for the given |session_id| so
 // it can be used to launch a process in that session.
-bool CreateSessionToken(uint32 session_id, ScopedHandle* token_out) {
+bool CreateSessionToken(uint32_t session_id, ScopedHandle* token_out) {
   ScopedHandle session_token;
   DWORD desired_access = TOKEN_ADJUST_DEFAULT | TOKEN_ADJUST_SESSIONID |
                          TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_QUERY;
   if (!CopyProcessToken(desired_access, &session_token)) {
     return false;
   }
 
   // Temporarily enable the SE_TCB_NAME privilege as it is required by
   // SetTokenInformation(TokenSessionId).
   ScopedHandle privileged_token;
@@ skipping 93 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