Switch to standard integer types in remoting/host/.

remoting/host/win/worker_process_launcher_unittest.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 "base/basictypes.h"
+#include <stdint.h>
+
 #include "base/bind.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_process_information.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/chromoting_messages.h"
@@ skipping 36 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(MockProcessLauncherDelegate);
 };
 
 class MockIpcDelegate : public WorkerProcessIpcDelegate {
  public:
   MockIpcDelegate() {}
   ~MockIpcDelegate() override {}
 
   // WorkerProcessIpcDelegate interface.
-  MOCK_METHOD1(OnChannelConnected, void(int32));
+  MOCK_METHOD1(OnChannelConnected, void(int32_t));
   MOCK_METHOD1(OnMessageReceived, bool(const IPC::Message&));
   MOCK_METHOD1(OnPermanentError, void(int));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockIpcDelegate);
 };
 
 class MockWorkerListener : public IPC::Listener {
  public:
   MockWorkerListener() {}
@@ skipping 27 matching lines @@
       public IPC::Listener {
  public:
   WorkerProcessLauncherTest();
   ~WorkerProcessLauncherTest() override;
 
   void SetUp() override;
   void TearDown() 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;
 
   // WorkerProcessLauncher::Delegate mocks
   void LaunchProcess(
       WorkerProcessLauncher* event_handler);
   void LaunchProcessAndConnect(
       WorkerProcessLauncher* event_handler);
   void FailLaunchAndStopWorker(
       WorkerProcessLauncher* event_handler);
   void KillProcess();
@@ skipping 89 matching lines @@
       .Times(0);
 }
 
 void WorkerProcessLauncherTest::TearDown() {
 }
 
 bool WorkerProcessLauncherTest::OnMessageReceived(const IPC::Message& message) {
   return event_handler_->OnMessageReceived(message);
 }
 
-void WorkerProcessLauncherTest::OnChannelConnected(int32 peer_pid) {
+void WorkerProcessLauncherTest::OnChannelConnected(int32_t peer_pid) {
   event_handler_->OnChannelConnected(peer_pid);
 }
 
 void WorkerProcessLauncherTest::OnChannelError() {
   event_handler_->OnChannelError();
 }
 
 void WorkerProcessLauncherTest::LaunchProcess(
     WorkerProcessLauncher* event_handler) {
   EXPECT_FALSE(event_handler_);
@@ skipping 294 matching lines @@
   EXPECT_CALL(client_listener_, OnCrash(_, _, _))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(
           this, &WorkerProcessLauncherTest::SendFakeMessageToLauncher));
 
   StartWorker();
   message_loop_.Run();
 }
 
 }  // namespace remoting