Switch to standard integer types in ppapi/.

ppapi/proxy/resource_message_test_sink.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 "ppapi/proxy/resource_message_test_sink.h"
 
+#include <stddef.h>
+
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/resource_message_params.h"
 #include "ppapi/proxy/serialized_handle.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 // Backend for GetAllResource[Calls|Replies]Matching.
-template<class WrapperMessage, class Params>
-std::vector<std::pair<Params, IPC::Message> >
-GetAllResourceMessagesMatching(const ResourceMessageTestSink& sink,
-                               uint32 id) {
+template <class WrapperMessage, class Params>
+std::vector<std::pair<Params, IPC::Message>> GetAllResourceMessagesMatching(
+    const ResourceMessageTestSink& sink,
+    uint32_t id) {
   std::vector<std::pair<Params, IPC::Message> > result;
   for (size_t i = 0; i < sink.message_count(); i++) {
     const IPC::Message* msg = sink.GetMessageAt(i);
     if (msg->type() == WrapperMessage::ID) {
       typename WrapperMessage::Param params;
       WrapperMessage::Read(msg, &params);
       Params cur_params = base::get<0>(params);
       IPC::Message cur_msg = base::get<1>(params);
       if (cur_msg.type() == id) {
         result.push_back(std::make_pair(cur_params, cur_msg));
@@ skipping 29 matching lines @@
   }
   return result;
 }
 
 void ResourceMessageTestSink::SetSyncReplyMessage(IPC::Message* reply_msg) {
   DCHECK(!sync_reply_msg_.get());
   sync_reply_msg_.reset(reply_msg);
 }
 
 bool ResourceMessageTestSink::GetFirstResourceCallMatching(
-    uint32 id,
+    uint32_t id,
     ResourceMessageCallParams* params,
     IPC::Message* nested_msg) const {
   ResourceCallVector matching_messages =
       GetAllResourceMessagesMatching<PpapiHostMsg_ResourceCall,
                                      ResourceMessageCallParams>(*this, id);
   if (matching_messages.empty())
     return false;
 
   *params = matching_messages[0].first;
   *nested_msg = matching_messages[0].second;
   return true;
 }
 
 bool ResourceMessageTestSink::GetFirstResourceReplyMatching(
-    uint32 id,
+    uint32_t id,
     ResourceMessageReplyParams* params,
     IPC::Message* nested_msg) {
   ResourceReplyVector matching_messages =
       GetAllResourceMessagesMatching<PpapiPluginMsg_ResourceReply,
                                      ResourceMessageReplyParams>(*this, id);
   if (matching_messages.empty())
     return false;
 
   *params = matching_messages[0].first;
   *nested_msg = matching_messages[0].second;
   return true;
 }
 
 ResourceMessageTestSink::ResourceCallVector
-ResourceMessageTestSink::GetAllResourceCallsMatching(uint32 id) {
+ResourceMessageTestSink::GetAllResourceCallsMatching(uint32_t id) {
   return GetAllResourceMessagesMatching<PpapiHostMsg_ResourceCall,
                                         ResourceMessageCallParams>(*this, id);
 }
 
 ResourceMessageTestSink::ResourceReplyVector
-ResourceMessageTestSink::GetAllResourceRepliesMatching(uint32 id) {
+ResourceMessageTestSink::GetAllResourceRepliesMatching(uint32_t id) {
   return GetAllResourceMessagesMatching<PpapiPluginMsg_ResourceReply,
                                         ResourceMessageReplyParams>(*this, id);
 }
 
 ResourceSyncCallHandler::ResourceSyncCallHandler(
     ResourceMessageTestSink* test_sink,
-    uint32 incoming_type,
+    uint32_t incoming_type,
     int32_t result,
     const IPC::Message& reply_msg)
     : test_sink_(test_sink),
       incoming_type_(incoming_type),
       result_(result),
       serialized_handle_(NULL),
-      reply_msg_(reply_msg) {
-}
+      reply_msg_(reply_msg) {}
 
 ResourceSyncCallHandler::~ResourceSyncCallHandler() {
 }
 
 bool ResourceSyncCallHandler::OnMessageReceived(const IPC::Message& msg) {
   if (msg.type() != PpapiHostMsg_ResourceSyncCall::ID)
     return false;
   PpapiHostMsg_ResourceSyncCall::Schema::SendParam send_params;
   bool success = PpapiHostMsg_ResourceSyncCall::ReadSendParam(
       &msg, &send_params);
@@ skipping 12 matching lines @@
       wrapper_reply_msg, reply_params, reply_msg_);
   test_sink_->SetSyncReplyMessage(wrapper_reply_msg);
 
   // Stash a copy of the message for inspection later.
   last_handled_msg_ = call_msg;
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi