Switch to standard integer types in chrome/.

chrome/renderer/media/cast_transport_sender_ipc.cc

 // Copyright 2014 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 "chrome/renderer/media/cast_transport_sender_ipc.h"
 
 #include "base/callback.h"
 #include "base/id_map.h"
 #include "chrome/common/cast_messages.h"
 #include "chrome/renderer/media/cast_ipc_dispatcher.h"
@@ skipping 40 matching lines @@
 
 void CastTransportSenderIPC::InitializeVideo(
     const media::cast::CastTransportRtpConfig& config,
     const media::cast::RtcpCastMessageCallback& cast_message_cb,
     const media::cast::RtcpRttCallback& rtt_cb) {
   clients_[config.ssrc].cast_message_cb = cast_message_cb;
   clients_[config.ssrc].rtt_cb = rtt_cb;
   Send(new CastHostMsg_InitializeVideo(channel_id_, config));
 }
 
-void CastTransportSenderIPC::InsertFrame(uint32 ssrc,
+void CastTransportSenderIPC::InsertFrame(
+    uint32_t ssrc,
     const media::cast::EncodedFrame& frame) {
   Send(new CastHostMsg_InsertFrame(channel_id_, ssrc, frame));
 }
 
 void CastTransportSenderIPC::SendSenderReport(
-    uint32 ssrc,
+    uint32_t ssrc,
     base::TimeTicks current_time,
-    uint32 current_time_as_rtp_timestamp) {
+    uint32_t current_time_as_rtp_timestamp) {
   Send(new CastHostMsg_SendSenderReport(channel_id_,
                                         ssrc,
                                         current_time,
                                         current_time_as_rtp_timestamp));
 }
 
 void CastTransportSenderIPC::CancelSendingFrames(
-    uint32 ssrc, const std::vector<uint32>& frame_ids) {
+    uint32_t ssrc,
+    const std::vector<uint32_t>& frame_ids) {
   Send(new CastHostMsg_CancelSendingFrames(channel_id_,
                                            ssrc,
                                            frame_ids));
 }
 
-void CastTransportSenderIPC::ResendFrameForKickstart(
-    uint32 ssrc, uint32 frame_id) {
+void CastTransportSenderIPC::ResendFrameForKickstart(uint32_t ssrc,
+                                                     uint32_t frame_id) {
   Send(new CastHostMsg_ResendFrameForKickstart(channel_id_,
                                                ssrc,
                                                frame_id));
 }
 
-void CastTransportSenderIPC::AddValidSsrc(uint32 ssrc) {
+void CastTransportSenderIPC::AddValidSsrc(uint32_t ssrc) {
   Send(new CastHostMsg_AddValidSsrc(channel_id_, ssrc));
 }
 
-
 void CastTransportSenderIPC::SendRtcpFromRtpReceiver(
-    uint32 ssrc,
-    uint32 sender_ssrc,
+    uint32_t ssrc,
+    uint32_t sender_ssrc,
     const media::cast::RtcpTimeData& time_data,
     const media::cast::RtcpCastMessage* cast_message,
     base::TimeDelta target_delay,
-    const media::cast::ReceiverRtcpEventSubscriber::RtcpEvents*
-    rtcp_events,
+    const media::cast::ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
     const media::cast::RtpReceiverStatistics* rtp_receiver_statistics) {
   // To avoid copies, we put pointers to objects we don't really
   // own into scoped pointers and then very carefully extract them again
   // before the scoped pointers go out of scope.
   media::cast::SendRtcpFromRtpReceiver_Params params;
   params.ssrc = ssrc;
   params.sender_ssrc = sender_ssrc;
   params.time_data = time_data;
   if (cast_message) {
     params.cast_message.reset(
@@ skipping 37 matching lines @@
   taken_frame_events->swap(
       const_cast<std::vector<media::cast::FrameEvent>&>(frame_events));
   scoped_ptr<std::vector<media::cast::PacketEvent>> taken_packet_events(
       new std::vector<media::cast::PacketEvent>());
   taken_packet_events->swap(
       const_cast<std::vector<media::cast::PacketEvent>&>(packet_events));
   raw_events_callback_.Run(taken_frame_events.Pass(),
                            taken_packet_events.Pass());
 }
 
-void CastTransportSenderIPC::OnRtt(uint32 ssrc, base::TimeDelta rtt) {
+void CastTransportSenderIPC::OnRtt(uint32_t ssrc, base::TimeDelta rtt) {
   ClientMap::iterator it = clients_.find(ssrc);
   if (it == clients_.end()) {
     LOG(ERROR) << "Received RTT report from for unknown SSRC: " << ssrc;
     return;
   }
   if (!it->second.rtt_cb.is_null())
     it->second.rtt_cb.Run(rtt);
 }
 
 void CastTransportSenderIPC::OnRtcpCastMessage(
-    uint32 ssrc,
+    uint32_t ssrc,
     const media::cast::RtcpCastMessage& cast_message) {
   ClientMap::iterator it = clients_.find(ssrc);
   if (it == clients_.end()) {
     LOG(ERROR) << "Received cast message from for unknown SSRC: " << ssrc;
     return;
   }
   if (it->second.cast_message_cb.is_null())
     return;
   it->second.cast_message_cb.Run(cast_message);
 }
@@ skipping 10 matching lines @@
   }
 }
 
 void CastTransportSenderIPC::Send(IPC::Message* message) {
   if (CastIPCDispatcher::Get()) {
     CastIPCDispatcher::Get()->Send(message);
   } else {
     delete message;
   }
 }