Switch to standard integer types in chrome/browser/, part 3 of 4.

chrome/browser/printing/cloud_print/test/cloud_print_proxy_process_browsertest.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.
 
 // Create a service process that uses a Mock to respond to the browser in order
 // to test launching the browser using the cloud print policy check command
 // line switch.
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/kill.h"
 #include "base/process/process.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/service_process/service_process_control.h"
 #include "chrome/browser/ui/startup/startup_browser_creator.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/service_messages.h"
 #include "chrome/common/service_process_util.h"
 #include "chrome/service/service_ipc_server.h"
@@ skipping 90 matching lines @@
 
   MockServiceIPCServer(
       ServiceIPCServer::Client* client,
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
       const IPC::ChannelHandle& handle,
       base::WaitableEvent* shutdown_event)
       : ServiceIPCServer(client, io_task_runner, handle, shutdown_event),
         enabled_(true) { }
 
   MOCK_METHOD1(OnMessageReceived, bool(const IPC::Message& message));
-  MOCK_METHOD1(OnChannelConnected, void(int32 peer_pid));
+  MOCK_METHOD1(OnChannelConnected, void(int32_t peer_pid));
   MOCK_METHOD0(OnChannelError, void());
 
   void SetServiceEnabledExpectations();
   void SetWillBeDisabledExpectations();
 
-  void CallServiceOnChannelConnected(int32 peer_pid) {
+  void CallServiceOnChannelConnected(int32_t peer_pid) {
     ServiceIPCServer::OnChannelConnected(peer_pid);
   }
 
   bool SendInfo();
 
  private:
   cloud_print::CloudPrintProxyInfo info_;
   bool enabled_;
 };
 
 // static
 std::string MockServiceIPCServer::EnabledUserId() {
   return std::string("kitteh@canhazcheezburger.cat");
 }
 
 void MockServiceIPCServer::SetServiceEnabledExpectations() {
   EXPECT_CALL(*this, OnChannelConnected(_)).Times(1)
       .WillRepeatedly(
           Invoke(this, &MockServiceIPCServer::CallServiceOnChannelConnected));
 
   EXPECT_CALL(*this, OnChannelError()).Times(0);
   EXPECT_CALL(*this, OnMessageReceived(_)).Times(0);
 
   EXPECT_CALL(*this,
-      OnMessageReceived(
-          Property(&IPC::Message::type,
-                   static_cast<int32>(ServiceMsg_GetCloudPrintProxyInfo::ID))))
-      .Times(AnyNumber()).WillRepeatedly(
+              OnMessageReceived(Property(
+                  &IPC::Message::type,
+                  static_cast<int32_t>(ServiceMsg_GetCloudPrintProxyInfo::ID))))
+      .Times(AnyNumber())
+      .WillRepeatedly(
           WithoutArgs(Invoke(this, &MockServiceIPCServer::SendInfo)));
 
-  EXPECT_CALL(*this,
-              OnMessageReceived(
-                  Property(&IPC::Message::type,
-                           static_cast<int32>(ServiceMsg_Shutdown::ID))))
+  EXPECT_CALL(*this, OnMessageReceived(Property(
+                         &IPC::Message::type,
+                         static_cast<int32_t>(ServiceMsg_Shutdown::ID))))
       .Times(1)
-      .WillOnce(
-          DoAll(Assign(&g_good_shutdown, true),
-                WithoutArgs(
-                    Invoke(g_service_process, &ServiceProcess::Shutdown)),
-                Return(true)));
+      .WillOnce(DoAll(
+          Assign(&g_good_shutdown, true),
+          WithoutArgs(Invoke(g_service_process, &ServiceProcess::Shutdown)),
+          Return(true)));
 }
 
 void MockServiceIPCServer::SetWillBeDisabledExpectations() {
   SetServiceEnabledExpectations();
 
   EXPECT_CALL(*this,
-              OnMessageReceived(
-                  Property(&IPC::Message::type,
-                           static_cast<int32>(
-                               ServiceMsg_DisableCloudPrintProxy::ID))))
+              OnMessageReceived(Property(
+                  &IPC::Message::type,
+                  static_cast<int32_t>(ServiceMsg_DisableCloudPrintProxy::ID))))
       .Times(AtLeast(1))
       .WillRepeatedly(DoAll(Assign(&enabled_, false), Return(true)));
 }
 
 bool MockServiceIPCServer::SendInfo() {
   if (enabled_) {
     info_.enabled = true;
     info_.email = EnabledUserId();
     EXPECT_TRUE(Send(new ServiceHostMsg_CloudPrintProxy_Info(info_)));
   } else {
@@ skipping 113 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> IOTaskRunner() {
     return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
   }
   base::Process Launch(const std::string& name);
   void WaitForConnect();
   bool Send(IPC::Message* message);
   void ShutdownAndWaitForExitWithTimeout(base::Process process);
 
   // IPC::Listener implementation
   bool OnMessageReceived(const IPC::Message& message) override { return false; }
-  void OnChannelConnected(int32 peer_pid) override;
+  void OnChannelConnected(int32_t peer_pid) override;
 
   // MultiProcessTest implementation.
   base::CommandLine MakeCmdLine(const std::string& procname) override;
 
   bool LaunchBrowser(const base::CommandLine& command_line, Profile* profile) {
     StartupBrowserCreator browser_creator;
     return StartupBrowserCreator::ProcessCmdLineImpl(
         command_line, base::FilePath(), false, profile,
         StartupBrowserCreator::Profiles(), &browser_creator);
   }
@@ skipping 147 matching lines @@
     base::Process process) {
   ASSERT_TRUE(Send(new ServiceMsg_Shutdown()));
 
   int exit_code = -100;
   bool exited = process.WaitForExitWithTimeout(TestTimeouts::action_timeout(),
                                                &exit_code);
   EXPECT_TRUE(exited);
   EXPECT_EQ(exit_code, 0);
 }
 
-void CloudPrintProxyPolicyStartupTest::OnChannelConnected(int32 peer_pid) {
+void CloudPrintProxyPolicyStartupTest::OnChannelConnected(int32_t peer_pid) {
   observer_.Notify();
 }
 
 base::CommandLine CloudPrintProxyPolicyStartupTest::MakeCmdLine(
     const std::string& procname) {
   base::CommandLine cl = MultiProcessTest::MakeCmdLine(procname);
   cl.AppendSwitchASCII(switches::kProcessChannelID, startup_channel_id_);
 #if defined(OS_MACOSX)
   cl.AppendSwitchASCII(kTestExecutablePath, executable_path_.value());
 #endif
@@ skipping 10 matching lines @@
   // LocalState for the BrowserProcess.  Must be created before profiles are
   // constructed.
   chrome::TestingIOThreadState testing_io_thread_state;
 
   base::Process process =
       Launch("CloudPrintMockService_StartEnabledWaitForQuit");
   WaitForConnect();
   ShutdownAndWaitForExitWithTimeout(process.Pass());
   content::RunAllPendingInMessageLoop();
 }