Switch to standard integer types in remoting/host/.

remoting/host/win/wts_session_process_delegate.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_delegate.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
@@ skipping 20 matching lines @@
     : public base::RefCountedThreadSafe<Core>,
       public base::MessagePumpForIO::IOHandler,
       public IPC::Listener {
  public:
   Core(scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
        scoped_ptr<base::CommandLine> target,
        bool launch_elevated,
        const std::string& channel_security);
 
   // Initializes the object returning true on success.
-  bool Initialize(uint32 session_id);
+  bool Initialize(uint32_t session_id);
 
   // Stops the object asynchronously.
   void Stop();
 
   // Mirrors WorkerProcessLauncher::Delegate.
   void LaunchProcess(WorkerProcessLauncher* event_handler);
   void Send(IPC::Message* message);
   void CloseChannel();
   void KillProcess();
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
   ~Core() override;
 
   // base::MessagePumpForIO::IOHandler implementation.
   void OnIOCompleted(base::MessagePumpForIO::IOContext* context,
                      DWORD bytes_transferred,
                      DWORD error) override;
 
   // IPC::Listener implementation.
   bool OnMessageReceived(const IPC::Message& message) override;
-  void OnChannelConnected(int32 peer_pid) override;
+  void OnChannelConnected(int32_t peer_pid) override;
   void OnChannelError() override;
 
   // The actual implementation of LaunchProcess()
   void DoLaunchProcess();
 
   // Drains the completion port queue to make sure that all job object
   // notifications have been received.
   void DrainJobNotifications();
 
   // Notified that the completion port queue has been drained.
@@ skipping 63 matching lines @@
     : caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_task_runner_(io_task_runner),
       channel_security_(channel_security),
       event_handler_(nullptr),
       get_named_pipe_client_pid_(nullptr),
       launch_elevated_(launch_elevated),
       launch_pending_(false),
       target_command_(target_command.Pass()) {
 }
 
-bool WtsSessionProcessDelegate::Core::Initialize(uint32 session_id) {
+bool WtsSessionProcessDelegate::Core::Initialize(uint32_t session_id) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Windows XP does not support elevation.
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     launch_elevated_ = false;
 
   if (launch_elevated_) {
     // GetNamedPipeClientProcessId() is available starting from Vista.
     HMODULE kernel32 = ::GetModuleHandle(L"kernel32.dll");
     CHECK(kernel32 != nullptr);
@@ skipping 121 matching lines @@
   }
 }
 
 bool WtsSessionProcessDelegate::Core::OnMessageReceived(
     const IPC::Message& message) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   return event_handler_->OnMessageReceived(message);
 }
 
-void WtsSessionProcessDelegate::Core::OnChannelConnected(int32 peer_pid) {
+void WtsSessionProcessDelegate::Core::OnChannelConnected(int32_t peer_pid) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Report the worker PID now if the worker process is launched indirectly.
   // Note that in this case the pipe's security descriptor is the only
   // protection against a malicious processed connecting to the pipe.
   if (launch_elevated_) {
     DWORD pid;
     if (!get_named_pipe_client_pid_(pipe_.Get(), &pid)) {
       PLOG(ERROR) << "Failed to retrive PID of the client";
       ReportFatalError();
@@ skipping 224 matching lines @@
   core_ = new Core(io_task_runner,
                    target_command.Pass(),
                    launch_elevated,
                    channel_security);
 }
 
 WtsSessionProcessDelegate::~WtsSessionProcessDelegate() {
   core_->Stop();
 }
 
-bool WtsSessionProcessDelegate::Initialize(uint32 session_id) {
+bool WtsSessionProcessDelegate::Initialize(uint32_t session_id) {
   return core_->Initialize(session_id);
 }
 
 void WtsSessionProcessDelegate::LaunchProcess(
     WorkerProcessLauncher* event_handler) {
   core_->LaunchProcess(event_handler);
 }
 
 void WtsSessionProcessDelegate::Send(IPC::Message* message) {
   core_->Send(message);
 }
 
 void WtsSessionProcessDelegate::CloseChannel() {
   core_->CloseChannel();
 }
 
 void WtsSessionProcessDelegate::KillProcess() {
   core_->KillProcess();
 }
 
 }  // namespace remoting