Switch to standard integer types in media/.

media/cast/logging/stats_event_subscriber_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 "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "base/values.h"
@@ skipping 49 matching lines @@
   base::SimpleTestTickClock receiver_clock_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   scoped_refptr<CastEnvironment> cast_environment_;
   test::FakeReceiverTimeOffsetEstimator fake_offset_estimator_;
   scoped_ptr<StatsEventSubscriber> subscriber_;
 };
 
 TEST_F(StatsEventSubscriberTest, CaptureEncode) {
   Init(VIDEO_EVENT);
 
-  uint32 rtp_timestamp = 0;
-  uint32 frame_id = 0;
+  uint32_t rtp_timestamp = 0;
+  uint32_t frame_id = 0;
   int extra_frames = 50;
   // Only the first |extra_frames| frames logged will be taken into account
   // when computing dropped frames.
   int num_frames = StatsEventSubscriber::kMaxFrameInfoMapSize + 50;
   int dropped_frames = 0;
   base::TimeTicks start_time = sender_clock_->NowTicks();
   // Drop half the frames during the encode step.
   for (int i = 0; i < num_frames; i++) {
     scoped_ptr<FrameEvent> capture_begin_event(new FrameEvent());
     capture_begin_event->timestamp = sender_clock_->NowTicks();
@@ skipping 58 matching lines @@
 
   it = stats_map.find(StatsEventSubscriber::AVG_CAPTURE_LATENCY_MS);
   ASSERT_TRUE(it != stats_map.end());
 
   EXPECT_DOUBLE_EQ(it->second, static_cast<double>(0.01));
 }
 
 TEST_F(StatsEventSubscriberTest, Encode) {
   Init(VIDEO_EVENT);
 
-  uint32 rtp_timestamp = 0;
-  uint32 frame_id = 0;
+  uint32_t rtp_timestamp = 0;
+  uint32_t frame_id = 0;
   int num_frames = 10;
   base::TimeTicks start_time = sender_clock_->NowTicks();
   AdvanceClocks(base::TimeDelta::FromMicroseconds(35678));
   base::TimeTicks first_event_time = sender_clock_->NowTicks();
   base::TimeTicks last_event_time;
   int total_size = 0;
   for (int i = 0; i < num_frames; i++) {
     int size = 1000 + base::RandInt(-100, 100);
     total_size += size;
     scoped_ptr<FrameEvent> encode_event(new FrameEvent());
@@ skipping 46 matching lines @@
   ASSERT_TRUE(it != stats_map.end());
 
   EXPECT_DOUBLE_EQ(
       it->second,
       (last_event_time - base::TimeTicks::UnixEpoch()).InMillisecondsF());
 }
 
 TEST_F(StatsEventSubscriberTest, Decode) {
   Init(VIDEO_EVENT);
 
-  uint32 rtp_timestamp = 0;
-  uint32 frame_id = 0;
+  uint32_t rtp_timestamp = 0;
+  uint32_t frame_id = 0;
   int num_frames = 10;
   base::TimeTicks start_time = sender_clock_->NowTicks();
   for (int i = 0; i < num_frames; i++) {
     scoped_ptr<FrameEvent> decode_event(new FrameEvent());
     decode_event->timestamp = receiver_clock_.NowTicks();
     decode_event->type = FRAME_DECODED;
     decode_event->media_type = VIDEO_EVENT;
     decode_event->rtp_timestamp = rtp_timestamp;
     decode_event->frame_id = frame_id;
     cast_environment_->logger()->DispatchFrameEvent(decode_event.Pass());
@@ skipping 14 matching lines @@
 
   base::TimeDelta duration = end_time - start_time;
   EXPECT_DOUBLE_EQ(
       it->second,
       static_cast<double>(num_frames) / duration.InMillisecondsF() * 1000);
 }
 
 TEST_F(StatsEventSubscriberTest, PlayoutDelay) {
   Init(VIDEO_EVENT);
 
-  uint32 rtp_timestamp = 0;
-  uint32 frame_id = 0;
+  uint32_t rtp_timestamp = 0;
+  uint32_t frame_id = 0;
   int num_frames = 10;
   int late_frames = 0;
   for (int i = 0, delay_ms = -50; i < num_frames; i++, delay_ms += 10) {
     base::TimeDelta delay = base::TimeDelta::FromMilliseconds(delay_ms);
     if (delay_ms > 0)
       late_frames++;
     scoped_ptr<FrameEvent> playout_event(new FrameEvent());
     playout_event->timestamp = receiver_clock_.NowTicks();
     playout_event->type = FRAME_PLAYOUT;
     playout_event->media_type = VIDEO_EVENT;
@@ skipping 13 matching lines @@
   StatsEventSubscriber::StatsMap::iterator it = stats_map.find(
       StatsEventSubscriber::NUM_FRAMES_LATE);
   ASSERT_TRUE(it != stats_map.end());
 
   EXPECT_DOUBLE_EQ(it->second, late_frames);
 }
 
 TEST_F(StatsEventSubscriberTest, E2ELatency) {
   Init(VIDEO_EVENT);
 
-  uint32 rtp_timestamp = 0;
-  uint32 frame_id = 0;
+  uint32_t rtp_timestamp = 0;
+  uint32_t frame_id = 0;
   int num_frames = 10;
   base::TimeDelta total_latency;
   for (int i = 0; i < num_frames; i++) {
     scoped_ptr<FrameEvent> capture_begin_event(new FrameEvent());
     capture_begin_event->timestamp = sender_clock_->NowTicks();
     capture_begin_event->type = FRAME_CAPTURE_BEGIN;
     capture_begin_event->media_type = VIDEO_EVENT;
     capture_begin_event->rtp_timestamp = rtp_timestamp;
     cast_environment_->logger()->DispatchFrameEvent(capture_begin_event.Pass());
 
@@ skipping 25 matching lines @@
       stats_map.find(StatsEventSubscriber::AVG_E2E_LATENCY_MS);
   ASSERT_TRUE(it != stats_map.end());
 
   EXPECT_DOUBLE_EQ(
       it->second, total_latency.InMillisecondsF() / num_frames);
 }
 
 TEST_F(StatsEventSubscriberTest, Packets) {
   Init(VIDEO_EVENT);
 
-  uint32 rtp_timestamp = 0;
+  uint32_t rtp_timestamp = 0;
   int num_packets = 10;
   int num_latency_recorded_packets = 0;
   base::TimeTicks start_time = sender_clock_->NowTicks();
   int total_size = 0;
   int retransmit_total_size = 0;
   base::TimeDelta total_network_latency;
   base::TimeDelta total_queueing_latency;
   base::TimeDelta total_packet_latency;
   int num_packets_transmitted = 0;
   int num_packets_received = 0;
@@ skipping 203 matching lines @@
       return false;
     return bucket_count == expected_count;
   }
   return false;
 }
 
 TEST_F(StatsEventSubscriberTest, Histograms) {
   Init(VIDEO_EVENT);
   AdvanceClocks(base::TimeDelta::FromMilliseconds(123));
 
-  uint32 rtp_timestamp = 123;
-  uint32 frame_id = 0;
+  uint32_t rtp_timestamp = 123;
+  uint32_t frame_id = 0;
 
   // 10 Frames with capture latency in the bucket of "10-14"ms.
   // 10 Frames with encode time in the bucket of "15-19"ms.
   for (int i = 0; i < 10; ++i) {
     ++frame_id;
     ++rtp_timestamp;
 
     scoped_ptr<FrameEvent> capture_begin_event(new FrameEvent());
     capture_begin_event->timestamp = sender_clock_->NowTicks();
     capture_begin_event->type = FRAME_CAPTURE_BEGIN;
@@ skipping 105 matching lines @@
 
   histogram = subscriber_->GetHistogramForTesting(
       StatsEventSubscriber::LATE_FRAME_MS_HISTO);
   ASSERT_TRUE(histogram);
   values = histogram->GetHistogram().Pass();
   EXPECT_TRUE(CheckHistogramHasValue(values.get(), "100-119", 1));
 }
 
 }  // namespace cast
 }  // namespace media