Switch to standard integer types in media/.

media/cast/net/rtp/cast_message_builder_unittest.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 <stdint.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/net/rtcp/rtcp.h"
 #include "media/cast/net/rtp/cast_message_builder.h"
 #include "media/cast/net/rtp/framer.h"
 #include "media/cast/net/rtp/rtp_defines.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 namespace cast {
 
 namespace {
-static const uint32 kSsrc = 0x1234;
-static const uint32 kShortTimeIncrementMs = 10;
-static const uint32 kLongTimeIncrementMs = 40;
-static const int64 kStartMillisecond = INT64_C(12345678900000);
+static const uint32_t kSsrc = 0x1234;
+static const uint32_t kShortTimeIncrementMs = 10;
+static const uint32_t kLongTimeIncrementMs = 40;
+static const int64_t kStartMillisecond = INT64_C(12345678900000);
 
-typedef std::map<uint32, size_t> MissingPacketsMap;
+typedef std::map<uint32_t, size_t> MissingPacketsMap;
 
 class NackFeedbackVerification : public RtpPayloadFeedback {
  public:
   NackFeedbackVerification()
       : triggered_(false), missing_packets_(), last_frame_acked_(0) {}
 
   void CastFeedback(const RtcpCastMessage& cast_feedback) final {
     EXPECT_EQ(kSsrc, cast_feedback.media_ssrc);
 
     last_frame_acked_ = cast_feedback.ack_frame_id;
@@ skipping 11 matching lines @@
             std::make_pair(frame_it->first, kRtcpCastAllPacketsLost));
       } else {
         missing_packets_.insert(
             std::make_pair(frame_it->first, frame_it->second.size()));
       }
       ++frame_it;
     }
     triggered_ = true;
   }
 
-  size_t num_missing_packets(uint32 frame_id) {
+  size_t num_missing_packets(uint32_t frame_id) {
     MissingPacketsMap::iterator it;
     it = missing_packets_.find(frame_id);
     if (it == missing_packets_.end())
       return 0;
 
     return it->second;
   }
 
   // Holds value for one call.
   bool triggered() {
     bool ret_val = triggered_;
     triggered_ = false;
     return ret_val;
   }
 
-  uint32 last_frame_acked() { return last_frame_acked_; }
+  uint32_t last_frame_acked() { return last_frame_acked_; }
 
  private:
   bool triggered_;
   MissingPacketsMap missing_packets_;  // Missing packets per frame.
-  uint32 last_frame_acked_;
+  uint32_t last_frame_acked_;
 
   DISALLOW_COPY_AND_ASSIGN(NackFeedbackVerification);
 };
 }  // namespace
 
 class CastMessageBuilderTest : public ::testing::Test {
  protected:
   CastMessageBuilderTest()
       : framer_(&testing_clock_,
                 &feedback_,
                 kSsrc,
                 true,
                 10),
         cast_msg_builder_(new CastMessageBuilder(&testing_clock_,
                                                  &feedback_,
                                                  &framer_,
                                                  kSsrc,
                                                  true,
                                                  0)) {
     rtp_header_.sender_ssrc = kSsrc;
     rtp_header_.is_key_frame = false;
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
   }
 
   ~CastMessageBuilderTest() override {}
 
-  void SetFrameIds(uint32 frame_id, uint32 reference_frame_id) {
+  void SetFrameIds(uint32_t frame_id, uint32_t reference_frame_id) {
     rtp_header_.frame_id = frame_id;
     rtp_header_.reference_frame_id = reference_frame_id;
   }
 
-  void SetPacketId(uint16 packet_id) { rtp_header_.packet_id = packet_id; }
+  void SetPacketId(uint16_t packet_id) { rtp_header_.packet_id = packet_id; }
 
-  void SetMaxPacketId(uint16 max_packet_id) {
+  void SetMaxPacketId(uint16_t max_packet_id) {
     rtp_header_.max_packet_id = max_packet_id;
   }
 
   void SetKeyFrame(bool is_key) { rtp_header_.is_key_frame = is_key; }
 
   void InsertPacket() {
     bool duplicate;
-    uint8 payload = 0;
+    uint8_t payload = 0;
     if (framer_.InsertPacket(&payload, 1, rtp_header_, &duplicate)) {
       cast_msg_builder_->CompleteFrameReceived(rtp_header_.frame_id);
     }
     cast_msg_builder_->UpdateCastMessage();
   }
 
   void SetDecoderSlowerThanMaxFrameRate(int max_unacked_frames) {
     cast_msg_builder_.reset(new CastMessageBuilder(&testing_clock_,
                                                    &feedback_,
                                                    &framer_,
@@ skipping 253 matching lines @@
 }
 
 TEST_F(CastMessageBuilderTest, SlowDownAck) {
   SetDecoderSlowerThanMaxFrameRate(3);
   SetFrameIds(0, 0);
   SetPacketId(0);
   SetMaxPacketId(0);
   SetKeyFrame(true);
   InsertPacket();
 
-  uint32 frame_id;
+  uint32_t frame_id;
   testing_clock_.Advance(
       base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
   SetKeyFrame(false);
   for (frame_id = 1; frame_id < 3; ++frame_id) {
     EXPECT_TRUE(feedback_.triggered());
     EXPECT_EQ(frame_id - 1, feedback_.last_frame_acked());
     SetFrameIds(frame_id, frame_id - 1);
     InsertPacket();
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
   }
   // We should now have entered the slowdown ACK state.
-  uint32 expected_frame_id = 1;
+  uint32_t expected_frame_id = 1;
   for (; frame_id < 10; ++frame_id) {
     if (frame_id % 2) {
       ++expected_frame_id;
       EXPECT_TRUE(feedback_.triggered());
     } else {
       EXPECT_FALSE(feedback_.triggered());
     }
     EXPECT_EQ(expected_frame_id, feedback_.last_frame_acked());
     SetFrameIds(frame_id, frame_id - 1);
     InsertPacket();
@@ skipping 10 matching lines @@
   SetFrameIds(frame_id, frame_id - 1);
   InsertPacket();
   testing_clock_.Advance(
       base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
   EXPECT_TRUE(feedback_.triggered());
   EXPECT_EQ(frame_id, feedback_.last_frame_acked());
 }
 
 }  // namespace cast
 }  // namespace media